集合总结(高一数学集合的概念笔记)

  本篇文章为你整理了集合总结(高一数学集合的概念笔记)的详细内容,包含有集合知识点归纳总结 高一数学集合的概念笔记 集合总结视频 集合总结视频洋葱 集合总结,希望能帮助你了解 集合总结。

  数组可以存基本数据类型和引用数据类型

  集合只能存引用数据类型,如果要存基本数据类型,需要存对应的包装类

  
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的观点,版权归原作者所有,仅为传播更多信息之目的,如有侵权请联系,我们将第一时间修改或删除,多谢。

留言与评论(共有 条评论)
   
验证码: