集合总结（高一数学集合的概念笔记）

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

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

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

　　
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软件开发工作室。