public static void main(String[] args) { // med4理论(); // med4String(); // med4for(); // med4switch(); // med4if(); // med4Arr(); // med4List(); // med4Set(); // med4LinkedHashSet(); med4Map(); } public static void med4理论() { /** 1. java基本数据类型有8种: byte: 8位, 对应的包装类Byte, 最小值: -2^7, 最大值: 2^7 - 1, 默认值是0, 例子：byte a = 100，byte b = -50 short: 16位, 对应的包装类Short, 最小值: -2^15, 最大值: 2^15 - 1, 默认值是0, 例子：short s = 1000，short r = -20000 int: 32位, 对应的包装类Integer, 最小值: -2^31, 最大值: 2^31 - 1, 默认值是0, 例子：int a = 100000, int b = -200000 long: 64位, 对应的包装类Long, 最小值: -2^63, 最大值: 2^63 - 1, 默认值是0L, 例子：long a = 100000L，long b = -200000L (long 数字后面加小写的l, Long数字后面加大写的L, 这里防止和数字1混淆故写成大写) float: 32位, 对应的包装类Float, 最小值: 1.4E - 45, 最大值: 3.4028235E38, 默认值: 0.0f, 单精度浮点数不能用来表示精确的值如货币, 例子：float f1 = 234.5f double: 64位, 对应的包装类Double, 最小值: 4.9E - 324, 最大值: 1.7976931348623157E308, 默认值: 0.0d, 双精度浮点数不能用来表示精确的值如货币, 例子：double d1 = 123.4d; boolean: true和false, 对应的包装类Boolean, 默认值:false, 例子：boolean one = true char: 16位, 对应的包装类Character, 是单个Unicode字符, 最小值: \u0000(即为0), 最大值: \uffff(即为65535), 例子：char letter = 'A' 2. 包装数据类型(即引用类型): 类, 接口, 数组, 枚举(也相当于类), 注解(相当于接口) 3. 装箱就是自动将基本数据类型转换为包装器类型；拆箱就是自动将包装器类型转换为基本数据类型 自动装箱: Integer total = 99; 自动拆箱: int totalprim = total; 4. 访问权限修饰符: 修饰符 本类 同包-子类 同包-非子类 不同包-子类 不同包-非子类 public 是 是 是 是 是 protected 是 是 是 是 否 默认 是 是 是 否 否 private 是 否 否 否 否 5. static: 修饰类, 方法, 字段时, 在字节码加载进jvm时就已经存在, 在整个程序中就只有一份, 不能通过 this.字段, 不能通过 this.方法名 修饰字段；类名.字段名, 比如: 当多个线程访问及修改某个类的全局静态变量时就可能会产生线程安全问题 修饰方法: 类名.方法名 修饰内部类: 类名.内部类 修饰代码块: 作用在字节码加载进jvm时就初始化一些变量 6. final : 修饰字段； 字段会变成常量, 常量不能重新赋值; 修饰方法: 则该方法不能被子类重写; 修饰类: 则该类不能有子类; 7. abstract : 抽象的, 和接口类似; 不能修饰字段, 抽象方法不能创建对象,即不能new 抽象类(); 修饰类: 则该类是抽象类, 子类如果不是抽象类则必须实现父类中的抽象方法; 抽象类中可以有抽象方法和非抽象方法; 修饰方法: 则方法为抽象方法, 抽象方法没有方法体, 如果一个类中包含后抽象方法, 则该类也必须加abstract修饰, 即含有抽象方法的类必须是抽象类 8. 接口: 参考: https://www.cnblogs.com/ladeng19/p/11677976.html 9. return : 结束当前这个方法; break: 结束当前这个循环; continue: 跳过循环中的这一步 */ }
String:
/** * String常用的方法 */ private static void med4String() { final String str = "小明-小红-小丽"; // 将字符串分隔为一个字符串数组 String[] split = str.split("-"); Stream.of(split).forEach(e -> System.out.print(e + "\t")); // 小明 小红 小丽 // 字符串拼接用 + 或 concat方法 或 String.format方法 String str2 = str + "-小伟"; out.println(str2); // 小明-小红-小丽-小伟 String str3 = str2.concat("-小朱").concat("-小A"); out.println(str3); // 小明-小红-小丽-小伟-小朱-小A String str4 = String.format("我是%s, 今年%d岁", "小B", 20); out.println(str4); // 我是小B, 今年20岁 // 判断字符串是否包含某些字符 boolean bool = str.contains("小红"); boolean bool2 = str.contains("小C"); out.println(String.format("bool=%s, bool2=%s", bool, bool2)); // bool=true, bool2=false // 判断是否以...开头 boolean bool3 = str.startsWith("小明-"); out.println(bool3); // true // 判断是否以...结尾 boolean bool4 = str.endsWith("丽"); out.println(bool4); // true // 比较2个字符串是否相等 boolean bool5 = "小明-小红-小丽".equals(str); out.println("bool5=" + bool5); // bool5=true // 忽略大小写进行比较2个字符串是否相等 boolean bool6 = "aaaBb".equalsIgnoreCase("AAABB"); out.println("bool6=" + bool6); // bool6=true // 字符串转换成大写 out.println("aaVb".toUpperCase()); // AAVB // 字符串转换成小写 out.println("aaVb".toLowerCase()); // aavb // 去除字符串2边的空格，中间空格不会去掉 out.println("值为:"+ " b a ".trim()); //值为:b a // 字符串截取 String s1 = str.substring(2, 6); out.println("s1=" + s1); // s1=-小红- // 获取字符串的长度 out.println("长度=" + str.length()); // 长度=8 // 将其它类型转换为字符串类型, 比如将int转为String String s2 = String.valueOf(123); out.println(s2); // 判断字符串是否为空 if (str == null || str.trim().length() == 0) { out.println("str为空"); } if (str == null || "".equals(str.trim())) { out.println("str为空"); } }
For循环语句:
/** * for循环 */ public static void med4for() { int[] intArr = new int[] {3, 1, 2, 5, 4}; for (int ele : intArr) { out.print(ele + "\t"); // 3 1 2 5 4 } for (int i = 0; i < intArr.length; i++) { out.print(intArr[i] + "\t"); // 3 1 2 5 4 3 1 2 5 4 } Stream.of(intArr).forEach(e -> out.print(e + "\t")); // 3 1 2 5 4 3 1 2 5 4 }
Switch:
/** * switch语句 */ public static void med4switch() { int ele = 2; switch (ele) { case 0 : out.println("ele等于0"); break; case 1 : out.println("ele等于1"); break; case 2 : out.println("ele等于2"); break; default: out.println("ele等于其它数值"); } // 打印结果: ele等于2 int e = 1; switch (e) { case 0 : out.println("e等于0"); break; case 1 : case 2 : out.println("e等于1或e等于2"); break; default: out.println("e等于其它数值"); } // 打印结果: e等于1或e等于2 }
If语句:
/** * if语句 */ public static void med4if() { boolean flag = true; if (flag) { out.println("flag等于true"); } // flag等于true boolean flag1 = false; if (flag1) { out.println("flag1等于true"); } else { out.println("flag1等于false"); } // flag1等于false int ele = 2; if (ele == 0) { out.println("ele等于0"); } else if (ele == 1) { out.println("ele等于1"); } else if (ele == 2) { out.println("ele等于2"); } else { out.println("ele大于2或者ele小于0"); } // ele等于2 }
数组的基本操作:
/** * 数组操作 */ public static void med4Arr() { // 创建方式 final int[] intArr1 = new int[] {1 , 3, 2, 5}; int[] intArr2 = {1 , 3, 2, 5}; int[] intArr3 = new int[4]; // 创建容量为4的数组 intArr3[0] = 1; intArr3[1] = 3; // 打印结果；[1, 3, 0, 0] 因为int如果不去赋值则默认是0; out.println(Arrays.toString(intArr3)); // 遍历intArr1数组打印成: [1 , 3, 2, 5] String str = toString(intArr1); out.println("str=" + str); // 获取数组长度 int len = intArr2.length; out.println("len=" + len); // 4 // 获取数组中某个索引位置元素 int i = intArr2[1]; out.println("第1个索引位置元素为:" + i); // 3 // 对数组进行排序 Arrays.sort(intArr2); out.println("intArr2排序后结果" + toString(intArr2)); // [1, 2, 3, 5] Integer[] iArr = new Integer[] {1, 6, 3, 2, 1}; Arrays.sort(iArr, new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { return o2 - o1; } }); out.print("iArr=" + Arrays.toString(iArr) + "\t"); // iArr=[6, 3, 2, 1, 1] out.println(); // 更新数组元素 intArr1[1] = 7; out.println(toString(intArr2)); // [1, 2, 3, 5] // 数组无法直接添加元素(如果要添加则需要扩容), 添加元素只能在创建数组时添加; 或者创建一个比旧的数组容量多1的新数组,将旧数组拷贝到新数组然后再添加 String[] strArr = {"aaa", "bbb", "ccc"}; String[] strArr2 = new String[strArr.length + 1]; for (int index = 0; index < strArr.length; index++) { strArr2[index] = strArr[index]; } strArr2[strArr2.length - 1] = "ddd"; out.println("strArr数组拷贝到新数组strArr2中并添加一个新元素ddd=" + Arrays.toString(strArr2)); // strArr数组拷贝到新数组strArr2中并添加一个新元素ddd=[aaa, bbb, ccc, ddd] // 数组无法直接删除元素(如果要删除则需要缩容), 比如: 删除第3个索引位置元素 int[] intArr4 = {1, 5, 2, 3, 6}; int[] intArr5 = new int[intArr4.length - 1]; for (int ii = 0; ii < intArr4.length; ii++) { if (ii == 3) { continue; } if (ii > 3) { intArr5[ii - 1] = intArr4[ii]; } else { intArr5[ii] = intArr4[ii]; } } out.println("intArr5=" + Arrays.toString(intArr5)); // 数组转换为集合 Integer[] integerArr = {1, 2, 3, 4}; List<Integer> integers = Arrays.asList(integerArr); integers.forEach(e -> out.print(e + "\t")); // 1 2 3 4 }
List集合的基本操作:
/** * list集合: 元素不会去重, 会记录元素添加的顺序, 底层是数组, 也是根据索引来存储的 */ public static void med4List() { List<Integer> list = new ArrayList<>(); list.add(5); list.add(1); list.add(3); list.add(3); list.add(4); list.add(2); out.println("集合长度为:" + list.size()); for (int i = 0; i < list.size(); i++) { out.print(list.get(i) + "\t"); // 5 1 3 3 4 2 } out.println(); // 获取索引为2的元素 Integer integer = list.get(2); out.println("integer=" + integer); // 3 // 将索引为2的元素修改为6 list.set(2, 6); for (Integer ele : list) { out.print(ele + "\t"); // 5 1 6 3 3 4 2 } out.println(); out.println("---------1---------"); // 删除索引为2的元素 list.remove(2); list.forEach(e -> out.print(e + "\t")); // 5 1 3 4 2 out.println(); out.println("---------2---------"); // 排序 List<Integer> list2 = Stream.of(5, 1, 6, 3, 3, 4, 2).collect(Collectors.toList()); list2.forEach(e -> out.print(e + "\t")); out.println(); // 5 1 6 3 3 4 2 list2.sort(new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { return o2 - o1; } }); list2.forEach(e -> out.print(e + "\t")); // 6 5 4 3 3 2 1 out.println(); out.println("---------3---------"); // 集合转换为数组 Integer[] list3 = list2.toArray(new Integer[0]); out.println(Arrays.toString(list3)); // [6, 5, 4, 3, 3, 2, 1] // 将一个集合添加到另一个集合中 List<Integer> integerList1 = new ArrayList<>(); integerList1.add(1); integerList1.add(2); integerList1.add(3); List<Integer> integerList2 = new ArrayList<>(); integerList2.add(4); integerList2.add(5); integerList1.addAll(integerList2); for (Integer ele : integerList1) { out.print(ele + " "); // 1 2 3 4 5 } // 清空集合所有元素 integerList1.clear(); out.println("删除integerList1集合后的值为:" + integerList1); // 删除integerList1集合后的值为:[] }
Set集合的基本操作:
/** * set集合: 元素会去重, 不会记录元素添加的顺序 * 因为HashSet底层是HashMap, 是Hash表存储, 不是根据索引来存储的; 所以不能根据索引来获取值; */ public static void med4Set() { Set<Integer> set = new HashSet<>(); set.add(1); set.add(3); set.add(3); set.add(2); set.add(5); set.add(4); out.println(set); // [1, 2, 3, 4, 5] // 获取集合长度 int size = set.size(); out.println("size=" + size); // 判断集合中是否包含有某个元素, 如果包含则删除此元素 boolean bool = set.contains(2); if (bool) { set.remove(2); } out.println("bool=" + bool); out.println(set); // [1, 3, 4, 5] // 将一个集合添加到另一个集合中 Set<Integer> set2 = new HashSet<>(); set2.add(11); set2.add(33); Set<Integer> set3 = new HashSet<>(); set3.add(22); set3.add(33); set3.add(44); set2.addAll(set3); out.println("set2=" + set2); // set2=[33, 22, 11, 44] // 删除集合中所有元素 set2.clear(); out.println("删除set2后值为:" + set2); // 删除set2后值为:[] }
LinkedHashSet集合的基本操作:
/** * LinkedHashSet: 会去重, 会记录元素添加顺序 */ public static void med4LinkedHashSet() { LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>(); linkedHashSet.add(3); linkedHashSet.add(2); linkedHashSet.add(5); linkedHashSet.add(1); linkedHashSet.add(2); linkedHashSet.add(4); out.println(linkedHashSet); // [3, 2, 5, 1, 4] }
HashMap集合的基本操作:
/** * HashMap: 会对key进行去重, 键值对, 底层是hash表存储 */ public static void med4Map() { Map<String, Integer> map = new HashMap<>(); map.put("张三", 10); map.put("李四", 20); map.put("张三", 30); map.put("赵六", 60); out.println(map); // {李四=20, 张三=30, 赵六=60} // 获取map的键值对个数 int size = map.size(); out.println("size=" + size); // size=3 // 根据key获取value Integer ele = map.get("赵六"); out.println(ele); // 60 // 判断是否包含有某个key boolean bool = map.containsKey("李四"); out.println("bool=" + bool); // 获取Map中所有的key Set<String> keySet = map.keySet(); out.println("keySet=" + keySet); // keySet=[李四, 张三, 赵六] for (String key : keySet) { out.print("key=" + key + ", value=" + map.get(key) + "\t"); // key=李四, value=20 key=张三, value=30 key=赵六, value=60 } out.println(); // 获取map中所有的value集合 Collection<Integer> values = map.values(); out.println("values=" + values); // values=[20, 30, 60] // 获取map中所有的键值对, 键值对由key-value组成 Set<Map.Entry<String, Integer>> entries = map.entrySet(); for (Map.Entry<String, Integer> entry : entries) { String key = entry.getKey(); Integer value = entry.getValue(); out.print("key=" + key + ", value=" + value + "\t"); // key=李四, value=20 key=张三, value=30 key=赵六, value=60 } out.println(); map.clear(); out.println("map清空后的值为:" + map); // map清空后的值为:{} } public static String toString(int[] a) { if (a == null) return "null"; int iMax = a.length - 1; if (iMax == -1) return "[]"; StringBuilder b = new StringBuilder(); b.append('['); for (int i = 0; ; i++) { b.append(a[i]); if (i == iMax) return b.append(']').toString(); b.append(", "); } }