浅谈java集合
来源：互联网 发布：迅雷cdn 知乎 编辑：程序博客网 时间：2024/06/05 04:12
一.
算法介绍（栈、队列、数组、链表、Hash、树）
面试题要点：数据结构：存储数据的方式 问题：常见数据结构的优缺点？
存储要点和优缺点概述
栈：先进后出，画图存储元素（A,B,C）（压栈），并取出（弹栈），画图进行演示
队列：先进先出，横向队列，存入取出，画图演示、
数组：查询快，增删慢(自己创建一个数组int[] arr = {11,13,45,67,34},
需求一：在45号元素后面增加一个元素23
需求二：删除元素45
需求三：我要获取45这个元素
链表：通过一个链子把多个结点（元素）连接起来，由数据和地址组成的一个元素，节点本身必须有一个地址值（就是下一个元素的地址值）
特点：查询慢，增删快
需求1：查询元素45，需要一个一个从头遍历
需求2：删除45这个元素，（1.保存45这个元素所保存的地址值 2.
断开链子 3.将第一个步骤中取得到的地址值赋值给45的下一个元素））
分为：单向链表：数据+下一个元素的地址
双向链表 ：数据+下一个元素的地址+上一个元素的地址
单向循环链表 ：最后一个元素存储的地址是第一个元素的地址值
双向循环链表：存储的是两个地址，最后一个元素所存储的两个地址分别是上一个元素的地址和第一个元素的地址
hash:一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，
变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，
不同的输入可能会散列成相同的输出，所以不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的信息压缩到
某一固定长度的消息摘要的函数。（讲解set集合的时候讲解） 
二叉树：（讲解set集合的时候讲解）
三.集合概念
3.1
案例：写一个学生数组，提出需求，根据需求分析数组和集合的区别
* 需求：存储5个学生对象，并输出学生对象的数据信息。
*
* 分析：
* A:定义学生类(name,age)
* B:定义学生数组，用于存储学生对象
* C:创建学生对象，给学生对象的成员变量赋值
* D:把创建好的学生对象添加到数组中
* E:遍历数组。
package com.edu_01;public class Student { private String name; private int age; //无参构造有参构造 public Student(){} public Student(String name,int age){ this.age = age; this.name = name; } //set/get public void setName(String name){ this.name = name; } public String getName(){ return name; } public void setAge(int age){ this.age = age; } public int getAge(){ return age; }}package com.edu_01;/** * 案例：写一个学生数组，提出需求，根据需求分析数组和集合的区别 * 需求：存储5个学生对象，并输出学生对象的数据信息。 * * 需求2：郭德纲又收了一个徒弟，我们怎么办呢？ * 分析：1.创建一个数组 * 2.将以前的元素和新的一个元素全部添加到新的数组中 * * 分析： 1.创建学生数组 * 2.创建学生类 * 3.创建学生对象 * 4.将学生对象存入数组 * 5.遍历并输出学生信息 * */public class Test { public static void main(String[] args) { // 1.创建学生数组 Student[] students = new Student[4]; // 2.创建学生对象 Student s = new Student("郭德纲", 40); Student s1 = new Student("于谦", 45); Student s2 = new Student("岳云鹏", 30); Student s3 = new Student("孙越", 30); // 3.给数组元素赋值 students[0] = s; students[1] = s1; students[2] = s2; students[3] = s3; //students[4] = "hellow"; // 遍历数组，并输出学生信息 for (int i = 0; i < students.length; i++) { System.out.println(students[i].getAge() + "--" + students[i].getName()); } }}
集合和数组的区别：数组不适应变化的需求,所有Java就提供了集合类供我们使用
数组：
1.长度固定
2.可以存储基本类型，也可以存储引用类型
3.存储元素类型一致
集合：
1.长度可变
2.只可以存储引用类型
3.可以存储多种类型
3.2
* 为什么出现集合类？
* 面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，我们就需要对这多个对象进行存储。
* 而目前为止我们学习过的可以存储多个元素的东西是数组，但是呢，数组长度固定，不能适应变化的需求，所以，Java
* 就提供了集合类供我们使用。
四.
4.1
* Java提供了集合类供我们使用，而我们的需求可能是这样的：
* 我要求我的元素是有序的，
* 我要求我的元素是无序的，
* 我要求我的元素是唯一的，
* 我要求我的元素是可以重复的。
* 为了满足不同的需求，Java就提供了不同的集合类。
* 而这些集合类由于数据结构不同，才可以满足这些条件的。
* 数据结构：存储元素的方式。
* 而无论这些集合的结构是什么样子的，都是要装水的，所以，他们应该有共性的内容。
* 通过不断的向上提取，最终会形成一个集合的继承体系图。
4.2
java API 集合类图介绍（主要看继承关系，画图讲解）
Collction体系结构图
Collection
List
ArrayList
Vector
LinkedList
Set
HashSet
TreeSet
五.开发中常类介绍
String,Math,Scanner,List,ArrayList,等等
集合部分：
1.Collection
1.1
简单介绍这个接口
是集合的顶层结构，定义了集合的共性功能。
可以存储对象，这些对象也被称为元素。
package com.edu_02;import java.util.ArrayList;import java.util.Collection;/** * * 成员方法：(看到E我们先把它理解为Object即可) * A:添加功能 * boolean add(Object obj):往集合中添加一个元素 * boolean addAll(Collection c):往集合中添加多个元素 * B:删除功能 * void clear():清空所有元素 * boolean remove(Object o):从集合中删除一个元素 * boolean removeAll(Collection c):从集合中删除另一个集合的元素 * C:判断功能 * boolean contains(Object o):判断集合中是否包含指定的元素 * boolean containsAll(Collection c):判断集合中是否包含另一个集合的元素 * boolean isEmpty():判断集合是否为空。 * D:交集功能 * boolean retainAll(Collection c) * * * G:集合转数组 Object[]toArray():把集合转成数组，然后遍历数组， 其实就相当于遍历了集合。(这个代码我们练习一次，就可以忘) * */public class CollectionDemo { public static void main(String[] args) { //创建collection这个接口的对象 //Collection c = new Collection();-- 接口不能被实例化 Collection c = new ArrayList(); //给这个集合里面存储5个字符串元素 String s = "hello"; String s1 = "word"; String s2 = "你好"; String s3 = "世界"; String s4 = "再见"; //将元素添加到集合中 //boolean add(Object obj):往集合中添加一个元素 c.add(s); c.add(s1); c.add(s2); c.add(s3); c.add(s4); c.add(new Integer(100));//是将int类型的100转换成引用类型的100，俗称自动装箱 /* //boolean addAll(Collection c):往集合中添加多个元素 //创建一个新的集合 Collection c1 = new ArrayList(); c1.add("haha"); c1.add("hehe"); //将新的这个集合添加到c这个集合中 c.addAll(c1); */ /* //void clear():清空所有元素 c.clear(); */ /* //boolean remove(Object o):从集合中删除一个元素 //删除成功地返回true,删除失败返回false boolean remove = c.remove("哈哈哈"); System.out.println(remove);*/ /* //boolean removeAll(Collection c):从集合中删除另一个集合的元素 Collection c1 = new ArrayList(); c1.add("hello"); c1.add("hehe"); //将新的这个集合添加到c这个集合中 //c.addAll(c1); boolean removeAll = c.removeAll(c1); //只要删除集合里面的一个元素就算删除成功 System.out.println(removeAll);*/ /* //boolean contains(Object o):判断集合中是否包含指定的元素 boolean contains = c.contains("hello"); System.out.println(contains);*/ /* //boolean containsAll(Collection c):判断集合中是否包含另一个集合的元素 Collection c1 = new ArrayList(); c1.add("hello"); c1.add("word"); boolean containsAll = c.containsAll(c1); System.out.println(containsAll);*/ /* //boolean isEmpty():判断集合是否为空。 c.clear(); boolean empty = c.isEmpty(); System.out.println(empty);*/ //D:交集功能 boolean retainAll(Collection c) Collection c1 = new ArrayList(); c1.add("hello"); c1.add("hehe"); boolean retainAll = c.retainAll(c1); //求出交集的元素，并删除集合中没有交集的元素 System.out.println(retainAll); //遍历这个集合 //首先将集合转换成数组 Object[] objects = c.toArray(); for (int i = 0; i < objects.length; i++) { Object object = objects[i]; System.out.println(object); } }}1.2（学习方法）
* 成员方法：(看到E我们先把它理解为Object即可)
* A:添加功能
* boolean add(Object obj):往集合中添加一个元素
* boolean addAll(Collection c):往集合中添加多个元素
* B:删除功能
* void clear():清空所有元素
* boolean remove(Object o):从集合中删除一个元素
* boolean removeAll(Collection c):从集合中删除另一个集合的元素
* C:判断功能
* boolean contains(Object o):判断集合中是否包含指定的元素
* boolean containsAll(Collection c):判断集合中是否包含另一个集合的元素
* boolean isEmpty():判断集合是否为空。
D:交集功能
* boolean retainAll(Collection c)
* E:迭代器(集合特有的遍历方式)
* Iterator iterator()
重点：Iterator的使用
A:使用步骤
B:迭代器原理
* F:长度功能
* int size():返回集合中元素的个数
*
* 面试题：
* 数组有length()吗?字符串有length()吗?集合有length()吗?
有 .length 有.length() 没有，他有一个size()方法
G:集合转数组
Object[]toArray():把集合转成数组，然后遍历数组，其实就相当于遍历了集合。(这个代码我们练习一次，就可以忘)
练习：
1.3
* 需求：往集合中添加三个字符串，并遍历。
*
* 分析：
* A:创建集合对象
* B:创建字符串对象
* C:把字符串对象添加到集合对象中
* D:遍历集合
*
* Object[] toArray():把集合转成数组，然后遍历数组，其实就相当于遍历了集合。
*
* 练习：
* 在集合中存储3个学生对象，并遍历。
1.4
* 迭代器：（分别创建String对象，Student对象添加集合遍历练习）
* Iterator iterator()
* Object next():返回迭代的下一个元素,并移动指向的位置
* boolean hasNext():判断是否有元素
*
* NoSuchElementException:没有这样的元素异常。
* 原因是：你已经获取到元素的末尾了，你还要继续获取元素，已经没有了，所以就报错了。
* 解决方案：你不要再拿了。我哪知道什么就不拿了啊?怎么办呢?就应该在拿之前判断一下是否有元素。
*
* 迭代器遍历集合：
* 迭代器是依赖于集合而存在的。所以，要想得到迭代器对象，必须先有集合对象。
*
* 迭代步骤：
* A:通过集合对象获取到迭代器对象
* B:通过迭代器对象的hasNext()方法判断是否有元素
* C:通过迭代器对象的next()方法获取元素
package com.edu_05;public class Student { private String name; private int age; public Student(String name, int age) { super(); this.name = name; this.age = age; } public Student() { super(); // TODO 自动生成的构造函数存根 } 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; }}package com.edu_05;import java.util.ArrayList;import java.util.Collection;import java.util.Iterator;import com.edu_04.Student;/** * 迭代器：作用：遍历结合 * * 迭代器：（分别创建String对象，Student对象添加集合遍历练习） * Iterator iterator() * Object next():返回迭代的下一个元素,并移动指向的位置 * boolean hasNext():判断是否有元素 * * NoSuchElementException:没有这样的元素异常。 * 原因是：你已经获取到元素的末尾了，你还要继续获取元素，已经没有了，所以就报错了。 * 解决方案：你不要再拿了。我哪知道什么就不拿了啊?怎么办呢?就应该在拿之前判断一下是否有元素。 * * 迭代器遍历集合： * 迭代器是依赖于集合而存在的。所以，要想得到迭代器对象，必须先有集合对象。 * * 迭代步骤： * A:通过集合对象获取到迭代器对象 * B:通过迭代器对象的hasNext()方法判断是否有元素 * C:通过迭代器对象的next()方法获取元素 * * */public class StudentTest { public static void main(String[] args) { //将三个学生对象存储到集合中 Collection c = new ArrayList(); c.add("hello"); c.add("world"); c.add("java"); //咱们使用迭代器进行遍历 Iterator it = c.iterator(); //用next()方法进行遍历// System.out.println(it.next());// System.out.println(it.next());// System.out.println(it.next());// //java.util.NoSuchElementException，没有你寻找的这个元素的异常// System.out.println(it.next()); /* if (it.hasNext()) { System.out.println(it.next()); } if (it.hasNext()) { System.out.println(it.next()); } if (it.hasNext()) { System.out.println(it.next()); } if (it.hasNext()) { System.out.println(it.next()); } if (it.hasNext()) { System.out.println(it.next()); }*/ while (it.hasNext()) { System.out.println(it.next()); } }}1.5
练习：创建狗对象（带参数），存储到集合，用迭代器进行遍历并打印对象的属性数据
//先创建狗这个类package com.edu_06;public class Dog { private String name; private int age; public Dog(String name, int age) { super(); this.name = name; this.age = age; } public Dog() { super(); // TODO 自动生成的构造函数存根 } 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; } public String toString() { return "Dog [name=" + name + ", age=" + age + "]"; }}package com.edu_06;import java.util.ArrayList;import java.util.Collection;import java.util.Iterator;public class DogTest { public static void main(String[] args) { //创建狗对象 Dog d = new Dog("大黄", 2); Dog d2 = new Dog("大白", 1); Dog d3 = new Dog("大黑", 3); //创建集合存储狗的元素 Collection c = new ArrayList(); c.add(d); c.add(d2); c.add(d3); for (Object object : c) { Dog d4 = (Dog)object; System.out.println(d4.getAge()+"--"+d4.getName()); } System.out.println("-----------------------"); //运用迭代器进行遍历 Iterator it = c.iterator(); while (it.hasNext()) { //System.out.println(it.next()); Dog next = (Dog)it.next(); System.out.println(next.getAge()+"--"+next.getName()); } }}2.List
(1)List集合的元素有序(存储和取出顺序一致),元素可重复
(2)List的特有功能： A:添加功能 void add(int index,Object obj):在指定的位置添加元素 B:删除功能 Object remove(int index):通过指定的索引删除元素，并把删除的元素返回 C:获取功能 get(int index) 返回列表中指定位置的元素。 D:替换功能 Object set(int index,Object obj)(3)案例： A:List存储字符串并遍历(迭代器,普通for) B:List存储自定义对象并遍历(迭代器,普通for)(4).List的倒序与洗牌 List中元素顺序可以被洗牌Collections.shuffle(list) List中元素顺序可以被倒序Collections.reverse(list) Collections.sort(list)对List元素排序（字母数字分别进行测试）案例练习：
* 需求：用List集合存储3个汽车对象，然后遍历。
*
* 汽车：Car
* 成员变量：String brand,int price,String color
* 构造方法：无参，带参
* 成员方法：getXxx()/setXxx()
*
* 注意事项：
* A:忘写main方法。
* B:导入包的问题，集合操作的时候，导入包基本上都是在java.util下
* C:大家针对我们的命名规范有些忘记了，需要回来再看一下
* 类，接口等名称是首字母大写
* 变量或者方法名首字母小写
3.ArrayList
案例1：存储字符串并遍历
案例2：存储自定义对象并遍历
4.LinkedList
案例1：存储字符串并遍历
案例2：存储自定义对象并遍历
* LinkedList特有功能:
* public void addFirst(E e)
* public void addLast(E e)
*
* public E getFirst()
* public E getLast()
*
* public E removeFirst()
* public E removeLast()
package com.edu_07;import java.util.ArrayList;import java.util.Iterator;import java.util.List;/** * (2)List的特有功能： A:添加功能 void add(int index,Object obj):在指定的位置添加元素 B:删除功能 Object remove(int index):通过指定的索引删除元素，并把删除的元素返回 C:获取功能 get(int index) 返回列表中指定位置的元素。 D:替换功能 Object set(int index,Object obj) * */public class ListDemo { public static void main(String[] args) { //创建一个List集合 List list = new ArrayList(); //给list集合添加几个字符串 list.add("hello"); list.add("world"); list.add("java"); list.add("java"); /* //void add(int index,Object obj):在指定的位置添加元素 //["hello","world","java"] list.add(1, "你好");//["hello","你好","world","java"]*/ /* //Object remove(int index):通过指定的索引删除元素，并把删除的元素返回 Object remove = list.remove(1); System.out.println(remove);*/ /* //get(int index) 返回列表中指定位置的元素。 Object object = list.get(1); System.out.println(object);*/ /* //利用for循环遍历集合 //System.out.println(list.size()); for(int i = 0;i<list.size();i++){ System.out.println(list.get(i)); }*/ //Object set(int index,Object obj) //list.set(1, "世界"); for (Object object : list) { System.out.println(object); } System.out.println("-------------------------"); //通过迭代器遍历这个集合 Iterator it = list.iterator(); while (it.hasNext()) { String next = (String)it.next(); System.out.println(next); } }}8.ArrayList与LinkedList的相同点与不同点 （面试题**）
相同点：有顺序的，元素可以重复
(1)ArrayList特点:
底层数据结构是数组,查询快,增删慢
线程不安全,效率高
(2)LinkedList特点:
底层数据结构是链表,查询慢,增删快
线程不安全,效率高
9.List的遍历（掌握）
1.for（普通for）
2.Iterator(迭代器)
3.foreach（增强for）
package com.edu_10;import java.util.ArrayList;import java.util.List;public class ArrayListDemo { public static void main(String[] args) { List<String> list = new ArrayList<String>(); //用法和之前学的相同 list.add("hello"); list.add("java"); list.add("C++"); //增强for循环， /** * foreach语句，一般用于集合的遍历 * * 格式：for(遍历出来的元素的数据类型 变量名：集合名){ * 可以直接使用遍历出来的对象 * } * */ for (Object object : list) { System.out.println(object); } }}10.泛型入门
引入：
案例：创建集合存储字符串，存储integer类型数据，遍历的时候强制转换
与String数组进行对比，引入泛型
泛型(掌握)
(1)是一种把明确数据类型的工作推迟到创建对象或者调用方法的时候才去明确类型的特殊类型
(2)格式：
<数据类型>
默认情况下，是Object类型。
这里数据类型只能是引用类型。如果你看到写基本类型也行，其实这里使用了自动装箱。
自动装箱：比如讲int类型通过创建对象形成Integer类型 例如：Integer IT = new Integer(100);
(3)好处：
A:把运行时期问题提前到了编译时期
B:避免了强制类型转换
C:优化程序设计，解决了黄色警告线问题
(4)在哪里用?
一般来说就是在集合中用的多。
看API,如果类或者接口或者方法出现了<>说明这里就有泛型。
拓展（有时间的话可以讲一讲，听懂了解就可以）：(5)泛型的概述(了解) A:泛型类（把泛型定义在类上） B:泛型方法（把泛型定义在方法上） C:泛型接口（泛型定义在接口上）(6)泛型通配符（先不进行讲解，后面会根据实例一一进行讲解）<?> 不确定类型<? extends E> 向上限定，E及其子类<? super E> 向下限定，E及及其父类package com.edu_12;import java.util.ArrayList;import java.util.Iterator;import java.util.List;/** * * 泛型的好处： * 1.解决了黄色警告线的问题 * 2.将运行时期的错误提前到了编译时期，明确了数据类型 * 3.避免了强制类型转换的麻烦 * */public class GenericDemo { public static void main(String[] args) { //给List集合创建的时候加入泛型 List<String> list = new ArrayList<String>(); list.add("hello"); list.add("你好"); //list.add(100);//-- 就成功的将运行期的异常提前到了编译时期 //使用迭代器遍历集合 Iterator<String> it = list.iterator(); while (it.hasNext()) { String string = it.next(); System.out.println(string); } }}二十九章：集合3_Set
1.Set
1.1常用方法：直接查看api，里面的方法我们基本都是学过的哦
2.HashSet（查询api看说明进行讲解）
2.1 元素顺序：元素唯一，但是无序（它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变）
案例：创建一个HashSet集合，添加元素（String元素），测试唯一性，无序性
package com.edu_01;import java.util.HashSet;/** * HashSet集合特点： * 1.迭代元素无序，特别是不保证迭代顺序不变 * 2.无重复元素出现 * 保证元素唯一性办法 * e.hash == hash&&((k = e.key) == key || e.equals(k)) * e.hash == Hash.(HashCode())方法 * (k = e.key) == key 比较的是地址值，如果地址值相同 * 返回值为true，则进行下面的比较 * e.equals(k)方法比较两者之间的内容是否相同 * 当然，它默认比较的是地址值，重写后可以比较内容 * 重写使用自动添加功能 * */public class HashSetDemo {public static void main(String[] args) { HashSet<String> hs1 = new HashSet<String>(); hs1.add("hello"); hs1.add("world"); hs1.add("boy"); for(String s : hs1){ System.out.println(s); }}}2.2如何保证元素的唯一性的呢（分析源码）?
* 通过简单的分析，我们知道HashSet集合保证元素的唯一性和add()方法相关。
* 如何我们想深入的了解，就必须看add()方法的源码，看它的底层依赖什么内容?
* if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {…}
*
* 左边：e.hash == hash
* 比较对象的哈希值。
*
* 右边：((k = e.key) == key || key.equals(k))
* 左边：(k = e.key) == key
* 比较对象的地址值。
*
* 右边：key.equals(k)
* 比较的是对象的内容是否相同。默认情况下比较的是地址值
结论： 底层数据结构是哈希表。 哈希表依赖两个方法：hashCode()和equals() 执行流程： 首先判断哈希值是否相同,如果不同，就直接添加到集合。 如果相同，继续执行equals()，看其返回值， 如果是false，就直接添加到集合。 如果是true，说明元素重复不添加。 使用： 如果你看到哈希结构的集合，就要考虑可能需要重写这两个方法。 如果真要重写，自动生成即可。 画图讲解哈希表结构：是一个元素为链表的数组结构知识点demo演练：
1.存储String类型的元素，说明元素无序且唯一
2.分析add()方法，保证唯一性的原理（底层依赖于hashCode()和equals()方法，保证了元素的唯一性）
3.存储自定义对象，如何保证元素的唯一性？（存储相同元素，发现无法保证元素的唯一性）
3.TreeSet（查看api，得出结论）
3.1 元素顺序：使用元素的自然顺序对元素进行排序，或者根据创建 set时提供的 Comparator进行排序，
具体取决于使用的构造方法。
3.2 底层算法：二叉树（画图进行讲解）
3.3 元素要求, 加入自定义JavaBean
package com.edu_03;import java.util.Iterator;import java.util.TreeSet;/** * 1.创建集合存储Integer类型的元素（20,18,23,22,17,24,19,18,24）， * 分析如何保证元素唯一性，以及排序的规则。 二叉树 * * TreeSet集合特点： * 1.保证元素的唯一性 * 2.实现了元素的排序 * *如何保证以上的特点？ *基于二叉树的数据结构。 * */public class TreeSetDemo {public static void main(String[] args) { TreeSet<Integer> ts = new TreeSet<Integer>(); ts.add(20); ts.add(18); ts.add(23); ts.add(22); ts.add(17); ts.add(24); ts.add(19); ts.add(18); ts.add(24); //两种遍历TreeSet()的方法 Iterator it = ts.iterator(); while(it.hasNext()) { System.out.print(it.next() + " "); } for(int i : ts) { System.out.println(i); }}}案例演练：
1.创建集合存储Integer类型的元素（20,18,23,22,17,24,19,18,24），分析如何保证元素唯一性，以及排序的规则。二叉树
（首先讲解二叉树数据结构是怎么存入元素的，根据compareTo()方法的返回值来确定要存入元素的安放位置）
2.存储字符串并遍历（字母a-z排序）
3.存入学生对象（姓名，年龄），1.按年龄排序，2.姓名排序（自然排序实现Comparable接口，并重写comparaTo()方法）
4.创建set集合的时候，传入Comparator（比较器排序）进行排序，进行排序（比较器排序）
//自然排序，实现Comparable接口，并且重写comparaTo()方法package com.edu_05;import java.util.Comparator;public class ComparatorImp implements Comparator<Student>{ //comparaTo(Student s)这个方法如出一辙 @Override public int compare(Student s1, Student s2) { /** * s1---this * s2---s * 需求：先按照年龄对学生对象进行排序？？如果学生的年龄相同， * 利用姓名对学生进行排序 */ //int num = s1.getAge() - s2.getAge(); int num = s2.getAge() - s1.getAge(); //如果年龄相同用姓名进行比较 int num2 = num==0?s1.getName().compareTo(s2.getName()):num; return num2; } }//创建学生类package com.edu_05;public class Student{ private String name; private int age; public Student(String name, int age) { super(); this.name = name; this.age = age; } public Student() { super(); // TODO 自动生成的构造函数存根 } 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; } //重写toString()方法 @Override public String toString() { return "Student [name=" + name + ", age=" + age + "]"; }}package com.edu_05;import java.util.TreeSet;/** * TreeSet集合利用比较器排序的方法对集合元素进行排序。 * TreeSet(Comparator comparator) * 我们目前所看到的这个构造方法，是需要一个Comparator这个接口的参数？ * 但是我们能直接传一个接口吗？不能，因为接口是不能被实例化，所以我们在这里 * 只能传递一个接口的实现类对象，让这个接口的实现类，去实现接口中的 * compare(Student s1,Student s2),在这个方法里面我们需要 * 书写我们的排序逻辑 * * */public class Test { public static void main(String[] args) { // 创建一个拥有比较器对象的集合 TreeSet<Student> ts = new TreeSet<Student>(new ComparatorImp()); //创建学生对象 Student s1 = new Student("aanbingbing",30); Student s2 = new Student("aanbingbing",20); Student s3 = new Student("cichen",40); Student s4 = new Student("eibingbing",35); Student s5 = new Student("fanwei",30); //将创建的学生对象存储集合 ts.add(s1); ts.add(s2); ts.add(s3); ts.add(s4); ts.add(s5); //遍历 for (Student student : ts) { System.out.println(student); } }}4.Set的遍历
4.1Iterator：
4.2foreach：
5.HashSet与TreeSet的相同点与不同点
相同点：
单列集合，元素不可重复
不同点
1. 底层存储的数据结构不同
HashSet底层用的是HashMap哈希表结构存储，而TreeSet底层用的是TreeMap树结构存储
2.存储时保证数据唯一性依据不同
HashSet是通过复写hashCode()方法和equals()方法来保证的，而TreeSet通过Compareable接口的compareTo()方法来保证的
3.有序性不一样
HashSet无序，TreeSet有序
* 这种情况的数据，属于一一对应的映射关系。这种关系的集合在java叫Map。
* Map：将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
- Map接口中的方法概述(创建集合测试方法)：
- A:删除功能
- void clear():移除集合中的所有键值对元素
- V remove(Object key):根据键移除键值对元素，并返回值
- B:判断功能
- boolean containsKey(Object key):判断集合中是否包含指定的键
- boolean containsValue(Object value):判断集合中是否包含指定的值
- boolean isEmpty():判断集合是否为空
- C:获取功能
- Set
package com.edu_07;import java.util.HashMap;import java.util.Map;import java.util.Set;/** * C:获取功能 Set<Map.Entry<K,V>> entrySet()：获取键值对对象的集合， 遍历键值对对象， * 利用getKey(),getValue()取出键和值（理解即可） * * V get(Object key):根据键获取值 Set<K> keySet():获取所有的键 Collection<V> values():获取所有的值 * */public class MapDemo2 { public static void main(String[] args) { // 创建map集合 Map<String, String> map = new HashMap<String, String>(); // 给集合添加元素 map.put("it001", "周杰伦"); map.put("it002", "罗玉凤"); map.put("it003", "如花"); map.put("it004", "王力宏"); // 遍历,根据键拿到了集合的值 System.out.println(map.get("it001")); System.out.println(map.get("it002")); System.out.println(map.get("it003")); System.out.println(map.get("it004")); System.out.println("------------------"); /*//通过键找值，俗称通过丈夫找妻子（必须掌握） // Set<K> keySet():获取所有的键的set集合 Set<String> keySet = map.keySet(); for (String s : keySet) { // System.out.println(s); System.out.println("key:" + s + "--" + "value:" + map.get(s)); }*/ }}2.HashMap
2.1元素顺序：元素顺序不可预测
2.2底层算法：哈希算法
2.3对键没有要求（仅仅相对于TreeMap来说）
知识点demo演练：
1.存入（String,String）主要讲解遍历方式，键：丈夫 值：妻子
2.存入（String,Student）键：String(国籍) 值：Student
3.存入（Student，String），键是同一个对象的时候要把之前存入的元素挤出去，想要实现这样的效果的话，
需要重写javabean里面的hashCode()和equals()方法
package com.edu_08;import java.util.HashMap;import java.util.Set;/** * 2.HashMap 2.1元素顺序：元素顺序不可预测 2.2底层算法：哈希算法 2.3对键没有要求(只是相对于TreeMap而言的) * * HashMap:集合特点 * 1.存入和取出顺序不一致 * */public class HashMapDemo { public static void main(String[] args) { //创建集合对象 HashMap<String, String> hm = new HashMap<String, String>(); //给集合中添加元素 hm.put("邓超", "孙俪"); hm.put("汪峰", "章子怡"); hm.put("周杰伦", "昆凌"); hm.put("习大大", "彭妈妈"); //通过键找值的方法，遍历这个集合 //返回的是一个HashSet集合 Set<String> keySet = hm.keySet(); //通过遍历键找值 for (String key : keySet) { System.out.println("key:"+key+"--"+"value:"+hm.get(key)); } }}3.Treemap
3.1元素顺序：元素顺序与键的排序规则有关
3.2底层算法：Tree算法
3.
知识点demo演练：
1.存入（Integer,String），主要验证排序方式
2.存入（Student，String），键：Student 值：地址
package com.edu_11;import java.util.Map;import java.util.Set;import java.util.TreeMap;/** * 3.Treemap 3.1元素顺序：元素顺序与键的排序规则有关 3.2底层算法：Tree算法 3.3元素要求：对键有要求，要求键必须实现一定的排序规则 知识点demo演练： 1.存入（Integer,String），主要验证排序方式 2.存入（Student，String），键：Student 值：地址 * @author Administrator * */public class TreeSetDemo { public static void main(String[] args) { // 1.存入（Integer,String），主要验证排序方式 //创建集合 TreeMap<Integer, String> tm = new TreeMap<Integer, String>(); //给集合添加元素 tm.put(1, "张学友"); tm.put(3, "黎明"); tm.put(2, "郭富城"); tm.put(4, "刘德华"); //遍历集合 //根据键取值,只需要掌握这种就行 Set<Integer> keySet = tm.keySet(); for (Integer key : keySet) { System.out.println("key:"+key+"--"+"value:"+tm.get(key)); } }}4.遍历（画图进行讲解）
集合遍历：1.获取建的集合 2.遍历键 3.根据键找值foreach()
1.foreach()：根据丈夫找妻子（根据键找值）
2.entrySet()：（Set
- 浅谈JAVA集合框架
- 浅谈JAVA集合框架
- 浅谈JAVA集合框架
- 浅谈JAVA集合框架
- 浅谈Java集合框架
- 浅谈JAVA集合框架
- java 集合浅谈
- 浅谈java集合类
- 浅谈java集合接口
- 浅谈JAVA集合框架
- Java 浅谈集合框架
- JAVA--浅谈集合
- Java集合浅谈
- 浅谈Java集合
- 浅谈java中的集合
- 浅谈java集合
- 浅谈java中的集合类
- 浅谈java集合之间区别
- 运算符的优先级
- Codeforces 404C Restore Graph 构造
- 《C语言及程序设计》教学视频 <18 链表中结点的插入和删除> 示例代码
- jquery自己写插件
- unity3d c#用于两个坦克对打血条的增减
- 浅谈java集合
- 玩转java多线程学习篇二 实例变量与线程安全
- Problem A: 大学的组织架构
- 决策树模型组合之随机森林与GBDT
- Zuma Game
- mybatis插入时返回自增主键
- JDBC操作步骤及数据库连接操作
- 欢迎使用CSDN-markdown编辑器
- OpenStack 和 Ceph 集成
