本篇文章为你整理了集合总结(高一数学集合的概念笔记)的详细内容,包含有集合知识点归纳总结 高一数学集合的概念笔记 集合总结视频 集合总结视频洋葱 集合总结,希望能帮助你了解 集合总结。
数组可以存基本数据类型和引用数据类型
集合只能存引用数据类型,如果要存基本数据类型,需要存对应的包装类
Iterator E iterator(): 返回此集合中元素的迭代器,通过集合对象的iterator()方法得到,迭代器对象一旦被创建,默认指向集合的0索引位置.
Iterator中的常用方法
boolean hasNext(): 判断当前位置是否有元素可以被取出 E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置
示例代码
public class MyCollectionDemo3 { public static void main(String[] args) { Collection String list = new ArrayList (); list.add("a"); list.add("b"); list.add("c"); list.add("d"); list.add("e"); //1,获得迭代器的对象 //迭代器对象一旦被创建,默认指向集合的0索引位置 Iterator String it = list.iterator(); //2.利用迭代器里面的方法进行遍历 /* boolean hasNext() 判断当前是否还有元素 E next() 取出当前元素,并指向下一个元素 */ while(it.hasNext()){ System.out.println(it.next()); } } }
void remove(): 删除迭代器对象当前指向的元素
public class IteratorDemo2 { public static void main(String[] args) { ArrayList String list = new ArrayList (); list.add("a"); list.add("b"); list.add("b"); list.add("c"); list.add("d"); Iterator String it = list.iterator(); while(it.hasNext()){ String s = it.next(); if("b".equals(s)){ //指向谁,那么此时就删除谁. it.remove(); } } System.out.println(list); } }
for(集合/数组中元素的数据类型 变量名 : 集合/数组名) {
// 已经将当前遍历到的元素封装到变量中了,直接使用变量即可
}
代码
public class MyCollectonDemo1 { public static void main(String[] args) { ArrayList String list = new ArrayList (); list.add("a"); list.add("b"); list.add("c"); list.add("d"); list.add("e"); list.add("f"); //1,数据类型一定是集合或者数组中元素的类型 //2,str仅仅是一个变量名而已,在循环的过程中,依次表示集合或者数组中的每一个元素 //3,list就是要遍历的集合或者数组 for(String str : list){ System.out.println(str); } } }
注意事项
public class MyCollectionDemo7 { public static void main(String[] args) { ArrayList String list = new ArrayList (); list.add("a"); list.add("b"); list.add("c"); list.add("d"); //str是第三方变量,对第三方变量的修改 不会影响集合原有值 for(String str : list){ str = "q"; System.out.println(str); } //集合或数组名.for 敲回车,快速生成增强for格式 for (String s : list) { System.out.println(s); } //System.out.println(list); } }
2.6Collection练习(应用)
public class MyCollectionDemo8 { public static void main(String[] args) { ArrayList Student list = new ArrayList (); list.add(new Student("小皮同学",23)); list.add(new Student("小路同学",31)); list.add(new Student("小贾同学",33)); //迭代器的方式进行遍历 Iterator Student it = list.iterator(); while(it.hasNext()){ Student s = it.next(); System.out.println(s); } System.out.println("-------------------------"); //增强for for (Student student : list) { System.out.println(student); } System.out.println("--------------------------"); //普通for循环 for (int i = 0; i list.size(); i++) { System.out.println(list.get(i)); } } }
3.List集合
3.1List集合的概述和特点(记忆)
用户可以精确控制列表中每个元素的插入位置,用户可以通过整数索引访问元素,并搜索列表中的元素
示例代码
public class MyListDemo1 { public static void main(String[] args) { List String list = new ArrayList (); list.add("aaa"); list.add("bbb"); list.add("ccc"); Iterator String it = list.iterator(); while(it.hasNext()){ String s = it.next(); System.out.println(s); } System.out.println("---------------------"); for (String s : list) { System.out.println(s); } } }
示例代码
public class MyListDemo2 { public static void main(String[] args) { List String list = new ArrayList (); list.add("aaa"); list.add("bbb"); list.add("ccc"); method1(list); method2(list); method3(list); method4(list); } private static void method4(List String list) { //E get(int index) 返回指定索引处的元素 String s = list.get(0); System.out.println(s); } private static void method3(List String list) { //E set(int index,E element) 修改指定索引处的元素,返回被修改的元素 //被替换的那个元素,在集合中就不存在了. String result = list.set(0, "qqq"); System.out.println(result); System.out.println(list); } private static void method2(List String list) { //E remove(int index) 删除指定索引处的元素,返回被删除的元素 //在List集合中有两个删除的方法 //第一个 删除指定的元素,返回值表示当前元素是否删除成功 //第二个 删除指定索引的元素,返回值表示实际删除的元素 String s = list.remove(0); System.out.println(s); System.out.println(list); } private static void method1(List String list) { //void add(int index,E element) 在此集合中的指定位置插入指定的元素 //原来位置上的元素往后挪一个索引. list.add(0,"qqq"); System.out.println(list); } }
ArrayList源码分析
ArrayList使用无参构造创建时,数组的长度为零。当ArrayList第一次添加元素时,创建一个新的长度为10的数组,后续每次数组要进行扩容时,每次扩大为原来的1.5倍。
LinkedList示例代码
public class MyLinkedListDemo3 { public static void main(String[] args) { LinkedList String list = new LinkedList (); list.add("aaa"); list.add("bbb"); list.add("ccc"); for (int i = 0; i list.size(); i++) { System.out.println(list.get(i)); } System.out.println("-------------------------"); Iterator String it = list.iterator(); while (it.hasNext()) { String s = it.next(); System.out.println(s); } System.out.println("--------------------------"); for (String s : list) { System.out.println(s); } } }
示例代码
public class MyLinkedListDemo4 { public static void main(String[] args) { LinkedList String list = new LinkedList (); list.add("aaa"); list.add("bbb"); list.add("ccc"); // public void addFirst(E e) 在该列表开头插入指定的元素 //method1(list); // public void addLast(E e) 将指定的元素追加到此列表的末尾 //method2(list); // public E getFirst() 返回此列表中的第一个元素 // public E getLast() 返回此列表中的最后一个元素 //method3(list); // public E removeFirst() 从此列表中删除并返回第一个元素 // public E removeLast() 从此列表中删除并返回最后一个元素 //method4(list); } private static void method4(LinkedList String list) { String first = list.removeFirst(); System.out.println(first); String last = list.removeLast(); System.out.println(last); System.out.println(list); } private static void method3(LinkedList String list) { String first = list.getFirst(); String last = list.getLast(); System.out.println(first); System.out.println(last); } private static void method2(LinkedList String list) { list.addLast("www"); System.out.println(list); } private static void method1(LinkedList String list) { list.addFirst("qqq"); System.out.println(list); } }
示例代码
/** * 不写泛型的弊端 */ public class GenericitySummarize { public static void main(String[] args) { ArrayList list = new ArrayList(); list.add("aaa"); list.add("bbb"); list.add("ccc"); list.add(123); Iterator it = list.iterator(); while(it.hasNext()){ String next = (String) it.next(); int len = next.length(); System.out.println(len); } } }
存储字符串并遍历
public class MySet1 { public static void main(String[] args) { //创建集合对象 Set String set = new TreeSet (); //添加元素 set.add("ccc"); set.add("aaa"); set.add("aaa"); set.add("bbb"); // for (int i = 0; i set.size(); i++) { // //Set集合是没有索引的,所以不能使用通过索引获取元素的方法 // } //遍历集合 Iterator String it = set.iterator(); while (it.hasNext()){ String s = it.next(); System.out.println(s); } System.out.println("-----------------------------------"); for (String s : set) { System.out.println(s); } } }
8.TreeSet集合
3.1TreeSet集合概述和特点【应用】
存储Integer类型的整数并遍历
public class MyTreeSet1 { public static void main(String[] args) { TreeSet Integer ts = new TreeSet (); ts.add(5); ts.add(3); ts.add(4); ts.add(1); ts.add(2); System.out.println(ts); } }
3.3自然排序Comparable的使用【应用】
学生类
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; } @Override public String toString() { return "Student{" + "name=" + name + \ + ", age=" + age + }; } @Override public int compareTo(Student o) { //按照对象的年龄进行排序 //主要判断条件: 按照年龄从小到大排序 int result = this.age - o.age; //次要判断条件: 年龄相同时,按照姓名的字母顺序排序 result = result == 0 ? this.name.compareTo(o.getName()) : result; return result; } }
测试类
public class MyTreeSet2 { public static void main(String[] args) { //创建集合对象 TreeSet Student ts = new TreeSet (); //创建学生对象 Student s1 = new Student("zhangsan",28); Student s2 = new Student("lisi",27); Student s3 = new Student("wangwu",29); Student s4 = new Student("zhaoliu",28); Student s5 = new Student("qianqi",30); //把学生添加到集合 ts.add(s1); ts.add(s2); ts.add(s3); ts.add(s4); ts.add(s5); //遍历集合 for (Student student : ts) { System.out.println(student); } } }
比较器排序,就是让集合构造方法接收Comparator的实现类对象,重写compare(T o1,T o2)方法
老师类
public class Teacher { private String name; private int age; public Teacher() { } public Teacher(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; } @Override public String toString() { return "Teacher{" + "name=" + name + \ + ", age=" + age + }; } }
测试类
public class MyTreeSet4 { public static void main(String[] args) { //创建集合对象 TreeSet Teacher ts = new TreeSet (new Comparator Teacher () { @Override public int compare(Teacher o1, Teacher o2) { //o1表示现在要存入的那个元素 //o2表示已经存入到集合中的元素 //主要条件 int result = o1.getAge() - o2.getAge(); //次要条件 result = result == 0 ? o1.getName().compareTo(o2.getName()) : result; return result; } }); //创建老师对象 Teacher t1 = new Teacher("zhangsan",23); Teacher t2 = new Teacher("lisi",22); Teacher t3 = new Teacher("wangwu",24); Teacher t4 = new Teacher("zhaoliu",24); //把老师添加到集合 ts.add(t1); ts.add(t2); ts.add(t3); ts.add(t4); //遍历集合 for (Teacher teacher : ts) { System.out.println(teacher); } } }
比较器排序: 创建TreeSet对象的时候传递Comparator的实现类对象,重写compare方法,根据返回值进行排序
自然排序
public int compareTo(Student o) { //this在前,参数在后,表示升序 //this在后,参数在前,表示降序 //根据age年龄升序,当年龄一样的时候,根据name姓名进行升序 int result = this.age - o.age; result = result == 0 ? this.name.compareTo(o.name) : result; return result; }
比较器排序
public int compare(String o1, String o2) { // o1在前表示升序, o1在后表示降序。 int result = o1.length() - o2.length(); result = result == 0 ? o1.compareTo(o2) : result; return result; }
示例代码
存入四个字符串,"c" "ab" "df" "qwer"按照长度排序,如果长度一样则按照首字母排序
public class MyTreeSet5 { public static void main(String[] args) { /*TreeSet String ts = new TreeSet (new Comparator String () { @Override public int compare(String o1, String o2) { int result = o1.length() - o2.length(); result = result == 0 ? o1.compareTo(o2) : result; return result; } });*/ //TreeSet带参构造 传递一个比较器对象 使用lambad表达式方式 TreeSet String ts = new TreeSet ( (String o1, String o2) - { int result = o1.length() - o2.length(); result = result == 0 ? o1.compareTo(o2) : result; return result; } ); ts.add("c"); ts.add("ab"); ts.add("df"); ts.add("qwer"); System.out.println(ts); } }
二叉树的特点
任意一个节点的度要小于等于2,即任意一个节点最多只能有二个子节点。
就是将根节点的右侧往左拉,原先的右子节点变成新的父节点,并把多余的左子节点出让,给已经降级的根节点当右子节点
就是将根节点的左侧往右拉,左子节点变成了新的父节点,并把多余的右子节点出让,给已经降级根节点当左子节点
如果一个节点没有子节点或者父节点,则该节点相应的指针属性值为Nil,这些Nil视为叶节点,每个叶节点(Nil)是黑色的
对每一个节点,从该节点到其所有后代叶节点的简单路径上,均包含相同数目的黑色节点
1.2HashSet集合的基本应用(应用)
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("java"); set.add("java"); set.add("java"); //迭代器遍历 Iterator String it = set.iterator(); while (it.hasNext()) { String next = it.next(); System.out.println(next); } System.out.println("================="); //增强for遍历 for (String s : set) { System.out.println(s); } } }
1.3哈希值(理解)
如果没有重写hashcode方法,那么就根据对象的地址值进行计算哈希值
针对同一个对象,返回的哈希值相同,针对不同的对象,返回的哈希值不同
如果重写了hashcode方法,一般都是根据对象的属性值来进行重写。
如果不同对象的属性值相同,那么它们的哈希值也是一样的。
示例代码
public class HashSetDemo2 { public static void main(String[] args) { Student s1 = new Student("张三",23); Student s2 = new Student("张三",23); Student s3 = new Student("李四",24); //如果Student类没有重写hashcode方法,则根据地址值计算哈希值 //如果重写了则一般根据属性值进行计算哈希值 System.out.println(s1.hashCode()); System.out.println(s2.hashCode()); System.out.println(s3.hashCode()); } } 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; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null getClass() != o.getClass()) return false; Student student = (Student) o; if (age != student.age) return false; return name != null ? name.equals(student.name) : student.name == null; } // 可以对Object类的hashCode()方法进行重写 // 根据对象的属性值计算哈希值 @Override public int hashCode() { int result = name != null ? name.hashCode() : 0; result = 31 * result + age; return result; } @Override public String toString() { return "Student{" + "name=" + name + \ + ", age=" + age + }; } }
学生类
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; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null getClass() != o.getClass()) return false; Student student = (Student) o; if (age != student.age) return false; return name != null ? name.equals(student.name) : student.name == null; } @Override public int hashCode() { int result = name != null ? name.hashCode() : 0; result = 31 * result + age; return result; } }
测试类
/* 创建一个存储学生对象的集合,存储多个学生对象,使用程序实现控制台遍历集合 要求:学生对象的成员变量值相同,我们就认为是同一个对象。 结论:HashSet集合存储自定义类型对象,那么必须重新hashcode和equals方法。 */ public class HashSetTest1 { public static void main(String[] args) { HashSet Student hs = new HashSet (); hs.add(new Student("xiaohei", 23)); hs.add(new Student("xiaohei", 23)); hs.add(new Student("xiaomei", 23)); for (Student s : hs) { System.out.println(s); } } }
总结
HashSet集合存储自定义类型元素,要想实现元素的唯一,要求必须重写hashCode方法和equals方法
示例代码
public class MyMap1 { public static void main(String[] args) { Map String,String map = new HashMap (); map.put("itheima001","小智"); map.put("itheima002","小美"); map.put("itheima003","大胖"); System.out.println(map); } }
示例代码
public class MyMap2 { public static void main(String[] args) { Map String,String map = new HashMap (); map.put("itheima001","小智"); map.put("itheima002","小美"); map.put("itheima003","大胖"); map.put("itheima004","小黑"); map.put("itheima005","大师"); //V put(K key,V value) 添加元素 method1(map); //V remove(Object key) 根据键删除键值对元素 method2(map); //void clear() 移除所有的键值对元素 method3(map); //boolean containsKey(Object key) 判断集合是否包含指定的键 method4(map); //boolean containsValue(Object value) 判断集合是否包含指定的值 method5(map); //boolean isEmpty() 判断集合是否为空 method6(map); //int size() 集合的长度,也就是集合中键值对的个数 method7(map); } private static void method7(Map String, String map) { //int size() 集合的长度,也就是集合中键值对的个数 int size = map.size(); System.out.println(size); } private static void method6(Map String, String map) { //boolean isEmpty() 判断集合是否为空 boolean empty1 = map.isEmpty(); System.out.println(empty1);//false map.clear(); boolean empty2 = map.isEmpty(); System.out.println(empty2);//true } private static void method5(Map String, String map) { //boolean containsValue(Object value) 判断集合是否包含指定的值 boolean result1 = map.containsValue("aaa"); boolean result2 = map.containsValue("小智"); System.out.println(result1); System.out.println(result2); } private static void method4(Map String, String map) { //boolean containsKey(Object key) 判断集合是否包含指定的键 boolean result1 = map.containsKey("itheima001"); boolean result2 = map.containsKey("itheima006"); System.out.println(result1); System.out.println(result2); } private static void method3(Map String, String map) { //void clear() 移除所有的键值对元素 map.clear(); System.out.println(map); } private static void method2(Map String, String map) { //V remove(Object key) 根据键删除键值对元素 String s = map.remove("itheima001"); System.out.println(s); System.out.println(map); } private static void method1(Map String, String map) { //V put(K key,V value) 添加元素 //如果要添加的键不存在,那么会把键值对都添加到集合中 //如果要添加的键是存在的,那么会覆盖原先的值,把原先值当做返回值进行返回。 String s = map.put("itheima001", "aaa"); System.out.println(s); System.out.println(map); } }
代码实现
public class MyMap3 { public static void main(String[] args) { //创建集合并添加元素 Map String,String map = new HashMap (); map.put("1号丈夫","1号妻子"); map.put("2号丈夫","2号妻子"); map.put("3号丈夫","3号妻子"); map.put("4号丈夫","4号妻子"); map.put("5号丈夫","5号妻子"); //获取到所有的键 Set String keys = map.keySet(); //遍历Set集合得到每一个键 for (String key : keys) { //通过每一个键key,来获取到对应的值 String value = map.get(key); System.out.println(key + "---" + value); } } }
代码实现
public class MyMap4 { public static void main(String[] args) { //创建集合并添加元素 Map String, String map = new HashMap (); map.put("1号丈夫", "1号妻子"); map.put("2号丈夫", "2号妻子"); map.put("3号丈夫", "3号妻子"); map.put("4号丈夫", "4号妻子"); map.put("5号丈夫", "5号妻子"); //首先要获取到所有的键值对对象。 //Set集合中装的是键值对对象(Entry对象) //而Entry里面装的是键和值 Set Map.Entry String, String entries = map.entrySet(); //遍历Set集合,得到每一个键值对对象 for (Map.Entry String, String entry : entries) { //通过entry对象的getKey获取键,getValue()获取值 String key = entry.getKey(); String value = entry.getValue(); System.out.println(key + "---" + value); } } }
创建一个HashMap集合,键是学生对象(Student),值是居住地 (String)。存储多个元素,并遍历。
学生类
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; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null getClass() != o.getClass()) return false; Student student = (Student) o; if (age != student.age) return false; return name != null ? name.equals(student.name) : student.name == null; } @Override public int hashCode() { int result = name != null ? name.hashCode() : 0; result = 31 * result + age; return result; } }
测试类
public class MyMap5 { public static void main(String[] args) { HashMap Student,String hm = new HashMap (); Student s1 = new Student("xiaohei",23); Student s2 = new Student("dapang",24); Student s3 = new Student("xiaomei",22); hm.put(s1,"江苏"); hm.put(s2,"北京"); hm.put(s3,"天津"); //第一种:先获取到所有的键,再通过每一个键来找对应的值 Set Student keys = hm.keySet(); for (Student key : keys) { String value = hm.get(key); System.out.println(key + "----" + value); } System.out.println("---------------------------------"); //第二种:先获取到所有的键值对对象。再获取到里面的每一个键和每一个值 Set Map.Entry Student, String entries = hm.entrySet(); for (Map.Entry Student, String entry : entries) { Student key = entry.getKey(); String value = entry.getValue(); System.out.println(key + "----" + value); } System.out.println("---------------------------------"); //第三种: hm.forEach( (Student student, String s) - { System.out.println(student + "---" + s); } ); } }
如果键存储的是自定义对象,需要实现Comparable接口或者在创建TreeMap对象时候给出比较器排序规则
创建一个TreeMap集合,键是学生对象(Student),值是籍贯(String),学生属性姓名和年龄,按照年龄进行排序并遍历
学生类
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; } @Override public String toString() { return "Student{" + "name=" + name + \ + ", age=" + age + }; } @Override public int compareTo(Student o) { //按照年龄进行排序 int result = o.getAge() - this.getAge(); //次要条件,按照姓名排序。 result = result == 0 ? o.getName().compareTo(this.getName()) : result; return result; } }
测试类
public class Test { public static void main(String[] args) { // 使用自然排序,要求键必须实现Comparable接口 // TreeMap Student,String tm = new TreeMap (); // 使用比较器排序 TreeMap Student,String tm = new TreeMap (new Comparator Student () { @Override public int compare(Student o1, Student o2) { int result = o1.getAge() - o2.getAge(); return (result== 0) ? o1.getName().compareTo(o2.getName()) : result; } }); Student s1 = new Student("xiaohei",23); Student s2 = new Student("dapang",22); Student s3 = new Student("xiaomei",22); tm.put(s1,"江苏"); tm.put(s2,"北京"); tm.put(s3,"天津"); tm.forEach( (Student key, String value)- { System.out.println(key + "---" + value); } ); } }
可变参数的基本使用
/** * 需求:定义一个方法求N个数的和 * 可变参数实现 */ public class MyVariableParameter3 { public static void main(String[] args) { int sum1 = getSum(1, 2); System.out.println(sum1); int sum2 = getSum(1, 2, 3); System.out.println(sum2); } public static int getSum(int... arr) { //说明可变数组 底层就是一个一维数组 这里是java的一个语法糖 // 什么叫语法糖? 一种语法 ,这种语法对功能没有影响,主要方便程序员开发和阅读。 // System.out.println(arr);//[I@10f87f48 int sum = 0; for (int i = 0; i arr.length; i++) { sum = sum + arr[i]; } return sum; } }
示例代码
public class MyVariableParameter4 { public static void main(String[] args) { // method1(); // method2(); // method3(); // method4(); } private static void method4() { Map String, String map = Map.ofEntries( Map.entry("zhangsan", "江苏"), Map.entry("lisi", "北京")); System.out.println(map); } private static void method3() { Map String, String map = Map.of("zhangsan", "江苏", "lisi", "北京", "wangwu", "天津"); System.out.println(map); } private static void method2() { //传递的参数当中,不能存在重复的元素。 Set String set = Set.of("a", "b", "c", "d","a"); System.out.println(set); } private static void method1() { List String list = List.of("a", "b", "c", "d"); System.out.println(list); //list.add("Q"); //list.remove("a"); //list.set(0,"A"); //System.out.println(list); //集合的批量添加。 //首先是通过调用List.of方法来创建一个不可变的集合,of方法的形参就是一个可变参数。 //再创建一个ArrayList集合,并把这个不可变的集合中所有的数据,都添加到ArrayList中。 ArrayList String list3 = new ArrayList (List.of("a", "b", "c", "d")); list3.add("1"); System.out.println(list3); } }
LinkedHashSet和LinkedHashMap: 可以实现去重并且存取有序的效果
/** * LinkedHashSet和LinkedHashMap: 可以实现去重并且存取有序的效果 */ public class LinkedHashSetDemo { public static void main(String[] args) { HashSet String hashSet = new HashSet (); hashSet.add("fff"); hashSet.add("aaa"); hashSet.add("bbb"); hashSet.add("ccc"); hashSet.add("ddd"); hashSet.add("ddd"); System.out.println("hashSet" + hashSet); LinkedHashSet String linkedHashSet = new LinkedHashSet (); linkedHashSet.add("fff"); linkedHashSet.add("aaa"); linkedHashSet.add("bbb"); linkedHashSet.add("ccc"); linkedHashSet.add("ddd"); linkedHashSet.add("ddd"); System.out.println("linkedHashSet" + linkedHashSet);
HashMap String, Integer hashMap = new HashMap (); hashMap.put("fff", 1); hashMap.put("aaa", 1); hashMap.put("bbb", 1); hashMap.put("ccc", 1); hashMap.put("ddd", 1); System.out.println("hashMap" + hashMap); LinkedHashMap String, Integer linkedHashMap = new LinkedHashMap (); linkedHashMap.put("fff", 1); linkedHashMap.put("aaa", 1); linkedHashMap.put("bbb", 1); linkedHashMap.put("ccc", 1); linkedHashMap.put("ddd", 1); System.out.println("linkedHashMap" + linkedHashMap); }
}
- 扩展二 // Java约定:如果二个对象equlas相等,那么hashcode也一定要相等,但是二个对象hashcode相等,equlas则不一定要相等。 public class HashSetDemo2 { public static void main(String[] args) { Student s1 = new Student("张三",23); Student s2 = new Student("张三",23); Student s3 = new Student("李四",24); //如果Student类没有重写hashcode方法,则根据地址值计算哈希值 //如果重写了则一般根据属性值进行计算哈希值 System.out.println(s1.hashCode()); System.out.println(s2.hashCode()); System.out.println(s3.hashCode()); System.out.println("-----------------------------"); // Java约定:如果二个对象equlas相等,那么hashcode也一定要相等, // 但是二个对象hashcode相等,equlas则不一定要相等。 //大部分情况不同的属性值计算出的哈希值都是不同的。但是也有例外 Student s4 = new Student("重地",23); Student s5 = new Student("通话",23); System.out.println(s4.hashCode()); // 36561268 System.out.println(s5.hashCode()); // 36561268 } }
以上就是集合总结(高一数学集合的概念笔记)的详细内容,想要了解更多 集合总结的内容,请持续关注盛行IT软件开发工作室。
郑重声明:本文由网友发布,不代表盛行IT的观点,版权归原作者所有,仅为传播更多信息之目的,如有侵权请联系,我们将第一时间修改或删除,多谢。