JavaSE进阶01：继承、修饰符
JavaSE进阶02：多态、抽象类、接口
JavaSE进阶03：内部类、Lambda表达式
JavaSE进阶04：API中常用工具类
JavaSE进阶05：包装类、递归、数组的高级操作、异常
JavaSE进阶06：Collection集合、迭代器、List、ArrayList、LinkedList
JavaSE进阶07：泛型、Set集合、TreeSet、二叉树、红黑树
JavaSE进阶08：HashSet、Map集合、HashMap、TreeMap、可变参数、不可变集合
JavaSE进阶09：Stream流、File类
JavaSE进阶10：IO流、字节流、字节缓冲流
JavaSE进阶11：字符流、字符缓冲流、转换流、对象操作流、Properties集合
JavaSE进阶12：多线程、线程同步、线程池
JavaSE进阶13：网络编程入门、UDP通信程序、TCP通信程序、日志、枚举
JavaSE进阶14：类加载器、反射
JavaSE进阶15：XML、注解、单元测试
JavaSE进阶扩充：JDK8 HashMap底层分析（了解）
JavaSE进阶扩充：JDK8 ArrayList线程安全问题和源码分析、集合常见面试题
Java进阶作业
存储字符串并遍历
import java.util.HashSet;
public class HashSetDemo {public static void main(String[] args) {//创建集合对象HashSet<String> set = new HashSet<String>();//添加元素set.add("hello");set.add("world");set.add("java");//不包含重复元素的集合set.add("world");//遍历for(String s : set) {System.out.println(s);}}
}
/*
world
java
hello
*/
哈希值（哈希码值）是JDK根据对象的地址或者属性值算出来的int类型的数值
如何获取哈希值
Object类中的public int hashCode()：返回对象的地址值算出来的哈希值
对象的哈希值的特点
加载因子决定了什么时候扩容，数组默认长度为16，加载因子默认为0.75。16*0.75=12，也就是当数组存了12个元素的时候，数组会扩容为原先的2倍。
底层扩容非常消耗性能，项目开发中最好指定数组长度initialCapacity。
注意事项
HashSet集合存储自定义类型元素,要想实现元素的唯一,要求必须重写hashCode方法和equals方法
IDEA重写快捷键：Alt+Ins->equals() and hashCode() 后一直下一步。
案例需求
/*学生类*/
import java.util.Objects;
public class Student {private String name;private int age;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}//Alt+Ins->equals() and hashCode() 一直下一步。@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;return age == student.age &&Objects.equals(name, student.name);}@Overridepublic int hashCode() {return Objects.hash(name, age);}
}/*测试类*/
import java.util.HashSet;
public class HashSetDemo02 {public static void main(String[] args) {//创建HashSet集合对象HashSet<Student> hs = new HashSet<Student>();//创建学生对象Student s1 = new Student("张三", 30);Student s2 = new Student("李四", 35);Student s3 = new Student("王五", 33);Student s4 = new Student("王五", 33);//把学生添加到集合hs.add(s1);hs.add(s2);hs.add(s3);hs.add(s4);//遍历集合(增强for)for (Student s : hs) {System.out.Name() + "," + s.getAge());}}
}
/*
王五,33
李四,35
张三,30
*/
Hashset实现原理：
Hashset底层使用HashMap来实现的，Set的元素存放在Map的Key上面。
对于hashmap来讲，它的主体是一个Entry数组，Entry又是一个链表。
Hashmap的存储过程如下：
1.计算Key的Hash值
2.把得到的Hash值作为数据下标去存储到Entry的数组中。在这里可能出现不一样的Key的得到的Hash值相等，相同的Hash值存在同一个数组元素下组成链表。（Entry是个结点，多个节点组成链表）
HashSet实际上存储元素的时候进行了获取Hash的操作，整形的Hash值就是自身，所以根据这个hash值得到数组的下标存储元素后，表现出来就是有序的。
TreeSet实现原理
TreeSet的底层使用treemap实现的，Set的元素存放在Map的Key上面.
TreeMap又是用红黑树进行实现，实际上红黑树是一种自平衡二叉查找树，它满足元素的有序性，因此TreeSet的元素是具有有序性的。
TreeSet和TreeMap当泛型是自定义类型时，底层没有相应的比较方法，就必须重写比较方法。
interface Map<K,V> K：键的类型；V：值的类型
Map集合的特点
import java.util.*;
public class MapDemo01 {public static void main(String[] args) {//创建集合对象Map<String,String> map = new HashMap<>();//V put(K key, V value) 将指定的值与该映射中的指定键相关联map.put("itheima001","张三");map.put("itheima002","李四");map.put("itheima003","王五");map.put("itheima001","赵六");map.put(null,"null1");map.put(null,"null2"); //输出集合对象System.out.println(map);//{null=null2, itheima003=王五, itheima001=赵六, itheima002=李四}}
}
方法介绍
| 方法名 | 说明 |
|---|---|
| V put(K key,V value) | 添加元素 |
| V remove(Object key) | 根据键删除键值对元素 |
| void clear() | 移除所有的键值对元素 |
| boolean containsKey(Object key) | 判断集合是否包含指定的键 |
| boolean containsValue(Object value) | 判断集合是否包含指定的值 |
| boolean isEmpty() | 判断集合是否为空 |
| int size() | 集合的长度，也就是集合中键值对的个数 |
import java.util.*;
public class MapDemo02 {public static void main(String[] args) {//创建集合对象Map<String,String> map = new HashMap<String,String>();//V put(K key,V value)：添加元素map.put("张三","张三老婆");map.put("李四","李四老婆");// remove(Object key)：根据键删除键值对元素System.out.ve("李四"));//李四老婆System.out.ve("李哥"));//null//void clear()：移除所有的键值对元素map.clear();System.out.println(map);//{}//boolean containsKey(Object key)：判断集合是否包含指定的键map.put("王五","王五老婆");System.out.ainsKey("王五"));//trueSystem.out.ainsKey("王哥"));//false//boolean isEmpty()：判断集合是否为空System.out.println(map.isEmpty());//false//int size()：集合的长度，也就是集合中键值对的个数System.out.println(map.size());//1//输出集合对象System.out.println(map);//{王五=王五老婆}}
}
方法介绍
| 方法名 | 说明 |
|---|---|
| V get(Object key) | 根据键获取值 |
| Set keySet() | 获取所有键的集合 |
| Collection values() | 获取所有值的集合 |
| Set<Map.Entry<K,V>> entrySet() | 获取所有键值对对象的集合 |
import java.util.*;
public class MapDemo03 {public static void main(String[] args) {//创建集合对象Map<String, String> map = new HashMap<String, String>();//添加元素map.put("1号丈夫", "1号妻子");map.put("2号丈夫", "2号妻子");map.put("3号丈夫", "3号妻子");System.out.println("---keySet():获取所有键的集合---");System.out.("1号丈夫"));System.out.("5号丈夫"));System.out.println("---keySet():获取所有键的集合---");Set<String> keySet = map.keySet();for(String key : keySet) {System.out.println(key);}System.out.println("---Collection<V> values():获取所有值的集合---");Collection<String> values = map.values();for(String value : values) {System.out.println(value);} }
}
import java.util.*;
import java.util.function.BiConsumer;
public class MapDemo02 {public static void main(String[] args) {//创建集合对象Map<String, String> map = new HashMap<>();//添加元素map.put("张三", "张三老婆");map.put("李四", "李四老婆");map.put("王五", "王五老婆");Set<String> keySet = map.keySet();//获取所有键的集合。用keySet()方法实现System.out.println("---方式一：增强for(键:键对象)---");for (String key : keySet) { //遍历键的集合，获取到每一个键。用增强for实现//根据键去找值。用get(Object key)方法实现String value = (key);System.out.println(key + ",,," + value);}System.out.println("---方式二：增强for（键值对:键值对对象）---");Set<Map.Entry<String, String>> entrySet1 = Set();//获取所有键值对对象的集合for (Map.Entry<String, String> me : entrySet1) {//遍历键值对对象的集合，得到每一个键值对对象//根据键值对对象获取键和值String key = me.getKey();String value = me.getValue();System.out.println(key + "。。。" + value);}System.out.println("---方式三：迭代器while()---");Set<Map.Entry<String, String>> entrySet2 = Set();//获取所有键值对对象的集合Iterator<Map.Entry<String, String>> iterator = entrySet2.iterator();while (iterator.hasNext()){Map.Entry<String, String> entry = ();String key = Key();String value = Value();System.out.println(key + "---" +value);}System.out.println("---方式四：forEach(匿名内部类BiConsumer)---");map.forEach(new BiConsumer<String, String>() {@Overridepublic void accept(String s, String s2) {System.out.println(s+"--->"+s2);}});System.out.println("---方式四：forEach(Lambda表达式)---");map.forEach((s,s2)-> System.out.println(s+"--->"+s2));}
}
/*
---方式一：增强for(键:键对象)---
李四,,,李四老婆
张三,,,张三老婆
王五,,,王五老婆
---方式二：增强for（键值对:键值对对象）---
李四。。。李四老婆
张三。。。张三老婆
王五。。。王五老婆
---方式三：迭代器while()---
李四---李四老婆
张三---张三老婆
王五---王五老婆
---方式四：forEach(匿名内部类BiConsumer)---
李四--->李四老婆
张三--->张三老婆
王五--->王五老婆
---方式四：forEach(Lambda表达式)---
李四--->李四老婆
张三--->张三老婆
王五--->王五老婆
*/
forEach在底层实质就是增强for循环。
案例需求
/*学生类*/
import java.util.Objects;public class Student {private String name;private int age;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}//Alt+Ins->equals() and hashCode() 一直下一步。@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;return age == student.age &&Objects.equals(name, student.name);}@Overridepublic int hashCode() {return Objects.hash(name, age);}@Overridepublic String toString() {return "Student{" +"name='" + name + ''' +", age=" + age +'}';}
}/*实现类*/
import java.util.*;
public class HashMapStudentDemo {public static void main(String[] args) {//创建HashMap集合对象HashMap<Student, String> hm = new HashMap<Student, String>();//创建学生对象Student s1 = new Student("张三", 30);Student s2 = new Student("李四", 35);Student s3 = new Student("王五", 33);Student s4 = new Student("王五", 33);//把学生添加到集合hm.put(s1, "西安");hm.put(s2, "武汉");hm.put(s3, "郑州");hm.put(s4, "北京");//遍历集合hm.forEach((Student key,String value)-> System.out.println(key+"----"+value));}
}
/*
Student{name='王五', age=33}----北京
Student{name='李四', age=35}----武汉
Student{name='张三', age=30}----西安*//*学生类*/
package lesson;public class Student implements Comparable<Student>{private String name;private int age;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "Student{" +"name='" + name + ''' +", age=" + age +'}';}@Overridepublic int compareTo(Student o) {//按照年龄进行排序int result = o.getAge() - Age();//次要条件，按照姓名排序。result = result == 0 ? o.getName()Name()) : result;return result;}
}
/*测试类*/
package lesson;import java.util.TreeMap;public class TreeMapStudentDemo {public static void main(String[] args) {// 创建TreeMap集合对象TreeMap<Student,String> tm = new TreeMap<>();// 创建学生对象Student s1 = new Student("xiaohei",23);Student s2 = new Student("dapang",22);Student s3 = new Student("xiaomei",22);Student s4 = new Student("xiaomei",22);// 将学生对象添加到TreeMap集合中tm.put(s1,"江苏");tm.put(s2,"北京");tm.put(s3,"天津");tm.put(s4,"天津");// 遍历TreeMap集合,打印每个学生的信息tm.forEach((Student key, String value)->{System.out.println(key + "---" + value);});}
}
/*
Student{name='xiaohei', age=23}---江苏
Student{name='xiaomei', age=22}---天津
Student{name='dapang', age=22}---北京*/
可变参数介绍
可变参数定义格式
修饰符 返回值类型 方法名(数据类型… 变量名) { }
/*
需求：定义一个方法球N个数的和，用可变参数实现*/
public class MyVariableParameter {public static void main(String[] args) {int sum=getSum("123",1,2,3,4,5,6);//多个参数时，可变参数必须放最后System.out.println(sum);}public static int getSum(String arr){System.out.println("我是不可变参数"+s);int sum=0;for (int i = 0; i < arr.length; i++) {sum+=arr[i];}return sum;}
}
/*
我是不可变参数123
21*/| 方法 | 介绍 |
|---|---|
| static List of(E…elements) | 创建一个具有指定元素的List集合对象 |
| static Set of(E…elements) | 创建一个具有指定元素的Set集合对象 |
| static <K , V> Map<K，V> of(E…elements) | 创建一个具有指定元素的Map集合对象 |
package homeWork2;import java.util.*;public class MyVariableParameter4 {public static void main(String[] args) {method1();//of方法创建的不可变的集合不能整删改//method2();//Set.off方法不可重复元素method3();//Map.of创建不可变键值对集合method4();//提高阅读性method5();//集合批量添加元素}private static void method5() {//首先是通过调用List.of方法来创建一个不可变的集合，of方法的形参就是一个可变参数。//再创建一个ArrayList集合，并把这个不可变的集合中所有的数据，都添加到ArrayList中。ArrayList<String> list2 = new ArrayList<>(List.of("a", "b", "c"));Collections.addAll(list2, "1","2","3");//批量添加方式1list2.addAll(Arrays.asList("A","B","C"));批量添加方式2System.out.println(list2);//[a, b, c, 1, 2, 3, A, B, C]}private static void method4() {Map<String, String> map = Map.("zhangsan", "江苏"),("lisi", "北京"));System.out.println(map);//{lisi=北京, zhangsan=江苏}}private static void method3() {Map<String, String> map = Map.of("zhangsan", "江苏", "lisi", "北京", "wangwu", "天津");System.out.println(map);//{zhangsan=江苏, lisi=北京, wangwu=天津}}private static void method2() {//传递的参数当中，不能存在重复的元素。Set<String> set = Set.of("a", "b", "c", "d","a");//报错}private static void method1() {List<String> list = List.of("a", "b", "c", "d");//list.add("Q");//添加报错//ve("a");//删除报错//list.set(0,"A");//修改报错}
}
本文发布于:2024-02-04 07:53:16，感谢您对本站的认可！
本文链接：https://www.4u4v.net/it/170702409653685.html
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系，我们将在24小时内删除。
| 留言与评论（共有 0 条评论） |
