01 ArrayList集合（案例） (array.add("hello"); //往ArrayList集合里面添加内容 )
02 三种迭代方式：迭代器迭代； 普通for循环； 增强for循环
03 增强for循环 ----增强for是用来替迭代器。
03 增强for循环的三种迭代方式：1. 遍历int数组 2. 遍历字符串数组 3. 遍历集合
04 List集合
05 Vector 集合 （ v.addElement("hello"); 往集合里面添加数据）
06 LinkedList （ link.add("hello"); ）
07 ArrayList去除集合中字符串的重复值(字符串的内容相同)
07-2 ArrayList去除集合中字符串的重复值(不能创建新的集合)
07-03 去除集合中自定义对象的重复值(对象的成员变量值都相同)
08-01 set （ set.add("hello"); ）
08-02 HashSet:存储字符串并遍历，自带去重的操作-------------HashSet底层依赖的是hashCode()和equals()方法。
08-03 存储自定义对象，并保证元素的唯一性。
08-04 HashSet集合存储自定义对象并遍历。
08-05 LinkedHashSet ：底层数据结构由哈希表和链表组成。
08-06 TreeSet：能够对元素按照某种规则进行排序。
（2） TreeSet存储自定义对象并保证排序和唯一。
(3) 请按照姓名的长度排序
(3)-02请按照姓名的长度排序
08-07 编写一个程序，获取10个1至20的随机数，要求随机数不能重复。
TreeSet 进行 ( 键盘录入5个学生信息 )
02 三种迭代方式：迭代器迭代； 普通for循环； 增强for循环
03 增强for循环 ----增强for是用来替迭代器。
03 增强for循环的三种迭代方式：1. 遍历int数组 2. 遍历字符串数组 3. 遍历集合
04 List集合
05 Vector 集合 （ v.addElement("hello"); 往集合里面添加数据）
06 LinkedList （ link.add("hello"); ）
07 ArrayList去除集合中字符串的重复值(字符串的内容相同)
07-2 ArrayList去除集合中字符串的重复值(不能创建新的集合)
07-03 去除集合中自定义对象的重复值(对象的成员变量值都相同)
08-01 set （ set.add("hello"); ）
08-02 HashSet:存储字符串并遍历，自带去重的操作-------------HashSet底层依赖的是hashCode()和equals()方法。
08-03 存储自定义对象，并保证元素的唯一性。
08-04 HashSet集合存储自定义对象并遍历。
08-05 LinkedHashSet ：底层数据结构由哈希表和链表组成。
08-06 TreeSet：能够对元素按照某种规则进行排序。
（2） TreeSet存储自定义对象并保证排序和唯一。
(3) 请按照姓名的长度排序
(3)-02请按照姓名的长度排序
08-07 编写一个程序，获取10个1至20的随机数，要求随机数不能重复。
TreeSet 进行 ( 键盘录入5个学生信息 )
=========================================
01 ArrayList集合（案例） (array.add("hello"); //往ArrayList集合里面添加内容 )
02 三种迭代方式：迭代器迭代； 普通for循环； 增强for循环
1.定义学生类-----里面定义name，age 以及相应的Student()类的空参有参构造，set(), get() 方法
//package cn.itcast_02; /** * 这是学生描述类 * * @author 风清扬 * @version V1.0 */ public class Student { // 姓名 private String name; // 年龄 private int age; public Student() { super(); } public Student(String name, int age) { super(); 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; } }
//1. 泛型遍历
Iterator<String> it = array.iterator();
while (it.hasNext()) {
String s = it.next();
System.out.println(s);
}
//2. 无泛型，用String强转
Iterator it2 = array.iterator();
while (it2.hasNext()) {
String s = (String) it2.next();
System.out.println(s);
}
import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class day16_02 { /* * List的子类特点： * ArrayList: * 底层数据结构是数组，查询快，增删慢 * 线程不安全，效率高 * Vector: * 底层数据结构是数组，查询快，增删慢 * 线程安全，效率低 * LinkedList: * 底层数据结构是链表，查询慢，增删快 * 线程不安全，效率高 * * 案例： * 使用List的任何子类存储字符串或者存储自定义对象并遍历。 * * ArrayList的使用。 * 存储字符串并遍历 */ public static void main(String[] args) { // 创建集合对象 ArrayList array = new ArrayList(); // 创建元素对象，并添加元素 array.add("hello"); array.add("world"); array.add("java"); //1. 泛型遍历 Iterator<String> it = array.iterator(); while (it.hasNext()) { String s = it.next(); System.out.println(s); } // 无泛型，用String强转 Iterator it2 = array.iterator(); while (it2.hasNext()) { String s = (String) it2.next(); System.out.println(s); } System.out.println("-----------"); for (int x = 0; x < array.size(); x++) { String s = (String) array.get(x); System.out.println(s); } } }
2. 使用 Student s1 = new Student("林青霞", 27);进行获取
import java.util.ArrayList; import java.util.Iterator; /* * 需求：ArrayList存储自定义对象并遍历。要求加入泛型，并用增强for遍历。 * A:迭代器 * B:普通for * C:增强for * LinkedList,Vector,Colleciton,List等存储我还讲吗?不讲解了，但是要求你们练习。 * 增强for是用来替迭代器。 */ public class day16_02 { public static void main(String[] args) { // 创建集合对象 ArrayList<Student> array = new ArrayList<Student>(); Student s1 = new Student("林青霞", 27); // 创建学生对象 Student s2 = new Student("貂蝉", 22); Student s3 = new Student("杨玉环", 24); Student s4 = new Student("西施", 21); Student s5 = new Student("王昭君", 23); array.add(s1); // 把学生对象添加到集合中 array.add(s2); array.add(s3); array.add(s4); array.add(s5); // 迭代器 Iterator<Student> it = array.iterator(); while (it.hasNext()) { Student s = it.next(); System.out.println(s.getName() + "---" + s.getAge()); } System.out.println("---------------"); // 普通for for (int x = 0; x < array.size(); x++) { Student s = array.get(x); System.out.println(s.getName() + "---" + s.getAge()); } System.out.println("---------------"); // 增强for for (Student s : array) { System.out.println(s.getName() + "---" + s.getAge()); } } } ==================== 林青霞---27 貂蝉---22 杨玉环---24 西施---21 王昭君---23 --------------- 林青霞---27 貂蝉---22 杨玉环---24 西施---21 王昭君---23 --------------- 林青霞---27 貂蝉---22 杨玉环---24 西施---21 王昭君---23
03 增强for循环 ----增强for是用来替迭代器。
* 增强for:是for循环的一种。
* 格式：
* for(元素数据类型 变量 : 数组或者Collection集合) {
* 使用变量即可，该变量就是元素
* }
* 好处：简化了数组和集合的遍历。
* 弊端： 增强for的目标不能为null。
* 如何解决呢?对增强for的目标先进行不为null的判断，然后在使用。
List<String> list = null; // 先定义集合----判断是否为空-----增强for
if (list != null) {
for (String s : list) {
System.out.println(s);
} }
03 增强for循环的三种迭代方式：1. 遍历int数组 2. 遍历字符串数组 3. 遍历集合
for (int x : arr) { // int型的增强for System.out.println(x); } for (String s : strArray) { System.out.println(s); }
import java.util.ArrayList; import java.util.Iterator; import java.util.List; /* * JDK5的新特性：自动拆装箱,泛型,增强for,静态导入,可变参数,枚举 /* * 增强for:是for循环的一种。 * 格式： * for(元素数据类型 变量 : 数组或者Collection集合) { * 使用变量即可，该变量就是元素 * } * 好处：简化了数组和集合的遍历。 * 弊端： 增强for的目标不能为null。 * 如何解决呢?对增强for的目标先进行不为null的判断，然后在使用。 */ public class day16_02 { public static void main(String[] args) { //1. 定义一个int数组 int[] arr = { 1, 2, 3, 4, 5 }; for (int x = 0; x < arr.length; x++) { System.out.println(arr[x]); } for (int x : arr) { // int型的增强for System.out.println(x); } //2. 定义一个字符串数组 String[] strArray = { "林青霞", "风清扬", "东方不败", "刘意" }; for (String s : strArray) { System.out.println(s); } //3. 定义一个集合 ArrayList<String> array = new ArrayList<String>(); array.add("hello"); array.add("world"); array.add("java"); for (String s : array) { System.out.println(s); } System.out.println("---------------"); List<String> list = null; // NullPointerException // 这个s是我们从list里面获取出来的，在获取前，它肯定还好做一个判断 // 说白了，这就是迭代器的功能 if (list != null) { for (String s : list) { System.out.println(s); } } // 增强for其实是用来替代迭代器的 //ConcurrentModificationException // for (String s : array) { // if ("world".equals(s)) { // array.add("javaee"); // } // } // System.out.println("array:" + array); } }
04 List集合
* List的子类特点： *ArrayList: * 底层数据结构是数组，查询快，增删慢 * 线程不安全，效率高 * Vector: * 底层数据结构是数组，查询快，增删慢 * 线程安全，效率低 * LinkedList: * 底层数据结构是链表，查询慢，增删快 * 线程不安全，效率高
05 Vector 集合 （ v.addElement("hello"); 往集合里面添加数据）
* Vector的特有功能： * 1：添加功能 * public void addElement(Object obj) -- add() * 2：获取功能 * public Object elementAt(int index) -- get() * public Enumeration elements() -- Iterator iterator() * boolean hasMoreElements() hasNext() * Object nextElement() next()
00
Enumeration en = v.elements(); // 返回的是实现类的对象
while (en.hasMoreElements()) {
String s = (String) en.nextElement();
System.out.println(s);
}
import java.util.ArrayList; import java.util.Enumeration; import java.util.Iterator; import java.util.List; import java.util.Vector; public class day16_02 { /* * Vector的特有功能： * 1：添加功能 * public void addElement(Object obj) -- add() * 2：获取功能 * public Object elementAt(int index) -- get() * public Enumeration elements() -- Iterator iterator() * boolean hasMoreElements() hasNext() */ public static void main(String[] args) { // 创建集合对象 Vector v = new Vector(); // 添加功能 v.addElement("hello"); v.addElement("world"); v.addElement("java"); // 遍历 for (int x = 0; x < v.size(); x++) { String s = (String) v.elementAt(x); System.out.println(s); } System.out.println("------------------"); Enumeration en = v.elements(); // 返回的是实现类的对象 while (en.hasMoreElements()) { String s = (String) en.nextElement(); System.out.println(s); } } } hello world java ------------------ hello world java
06 LinkedList （ link.add("hello"); ）
LinkedList的特有功能： A:添加功能 public void addFirst(Object e) B:获取功能 public Object getFirst() public Obejct getLast() C:删除功能 public Object removeFirst() public Object removeLast()
import java.util.LinkedList; public class day16_02 { /* * LinkedList的特有功能： * A:添加功能 * public void addFirst(Object e) * public void addLast(Object e) * B:获取功能 * public Object getFirst() * public Obejct getLast() * C:删除功能 * public Object removeFirst() * public Object removeLast() */ public static void main(String[] args) { // 创建集合对象 LinkedList link = new LinkedList(); // 添加元素 link.add("hello"); link.add("world"); link.add("java"); link.addFirst("javaee"); link.addLast("android"); System.out.println("getFirst:" + link.getFirst()); System.out.println("getLast:" + link.getLast()); System.out.println("removeFirst:" + link.removeFirst()); System.out.println("removeLast:" + link.removeLast()); // 输出对象名 System.out.println("link:" + link); } } getFirst:javaee getLast:android removeFirst:javaee removeLast:android link:[hello, world, java]
07 ArrayList去除集合中字符串的重复值(字符串的内容相同)
分析：
* A:创建集合对象
* B:添加多个字符串元素(包含内容相同的)
* C:创建新集合
* D:遍历旧集合,获取得到每一个元素
* E:拿这个元素到新集合去找，看有没有
* 有：不搭理它
* 没有：就添加到新集合
* F:遍历新集合
import java.util.ArrayList; import java.util.Iterator; public class day16_02 { /* * ArrayList去除集合中字符串的重复值(字符串的内容相同) * 分析： * A:创建集合对象 * B:添加多个字符串元素(包含内容相同的) * C:创建新集合 * D:遍历旧集合,获取得到每一个元素 * E:拿这个元素到新集合去找，看有没有 * 有：不搭理它 * 没有：就添加到新集合 * F:遍历新集合 */ public static void main(String[] args) { // 创建集合对象 ArrayList array = new ArrayList(); // 添加多个字符串元素(包含内容相同的) array.add("hello"); array.add("world"); array.add("java"); array.add("world"); array.add("java"); array.add("world"); array.add("world"); array.add("world"); array.add("world"); array.add("java"); array.add("world"); // 创建新集合 ArrayList newArray = new ArrayList(); // 遍历旧集合,获取得到每一个元素 Iterator it = array.iterator(); while (it.hasNext()) { String s = (String) it.next(); // 拿这个元素到新集合去找，看有没有 if (!newArray.contains(s)) { newArray.add(s); } } // 遍历新集合 for (int x = 0; x < newArray.size(); x++) { String s = (String) newArray.get(x); System.out.println(s); } } } ============= hello world java
07-2 需求：ArrayList去除集合中字符串的重复值(不能创建新的集合)
// 由选择排序思想引入，我们就可以通过这种思想做这个题目 // 拿0索引的依次和后面的比较，有就把后的干掉 // 同理，拿1索引... for (int x = 0; x < array.size() - 1; x++) { for (int y = x + 1; y < array.size(); y++) { if (array.get(x).equals(array.get(y))) { //拿0索引的依次和后面的比较，有就把后的干掉 array.remove(y); y--; } } }
import java.util.ArrayList; import java.util.Iterator; public class day16_02 { /* * 需求：ArrayList去除集合中字符串的重复值(字符串的内容相同) * 要求：不能创建新的集合，就在以前的集合上做。 */ public static void main(String[] args) { // 创建集合对象 ArrayList array = new ArrayList(); // 添加多个字符串元素(包含内容相同的) array.add("hello"); array.add("world"); array.add("java"); array.add("world"); array.add("java"); array.add("world"); array.add("world"); array.add("world"); array.add("world"); array.add("java"); array.add("world"); // 由选择排序思想引入，我们就可以通过这种思想做这个题目 // 拿0索引的依次和后面的比较，有就把后的干掉 // 同理，拿1索引... for (int x = 0; x < array.size() - 1; x++) { for (int y = x + 1; y < array.size(); y++) { if (array.get(x).equals(array.get(y))) { //拿0索引的依次和后面的比较，有就把后的干掉 array.remove(y); y--; } } } // 遍历集合 Iterator it = array.iterator(); while (it.hasNext()) { String s = (String) it.next(); System.out.println(s); } } }
07-03 去除集合中自定义对象的重复值(对象的成员变量值都相同)
package cn.itcast_04; public class Student { private String name; private int age; public Student() { super(); } public Student(String name, int age) { super(); 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 obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Student other = (Student) obj; if (age != other.age) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } }
import java.util.ArrayList; import java.util.Iterator; public class day16_02 { /* * 需求：去除集合中自定义对象的重复值(对象的成员变量值都相同) * * 我们按照和字符串一样的操作，发现出问题了。 * 为什么呢? * 我们必须思考哪里会出问题? * 通过简单的分析，我们知道问题出现在了判断上。 * 而这个判断功能是集合自己提供的，所以我们如果想很清楚的知道它是如何判断的，就应该去看源码。 * contains()方法的底层依赖的是equals()方法。 * 而我们的学生类中没有equals()方法，这个时候，默认使用的是它父亲Object的equals()方法 * Object()的equals()默认比较的是地址值，所以，它们进去了。因为new的东西，地址值都不同。 * 按照我们自己的需求，比较成员变量的值，重写equals()即可。 * 自动生成即可。 */ public static void main(String[] args) { // 创建集合对象 ArrayList array = new ArrayList(); // 创建学生对象 Student s1 = new Student("林青霞", 27); Student s2 = new Student("林志玲", 40); Student s3 = new Student("凤姐", 35); Student s4 = new Student("芙蓉姐姐", 18); Student s5 = new Student("翠花", 16); Student s6 = new Student("林青霞", 27); Student s7 = new Student("林青霞", 18); // 添加元素 array.add(s1); array.add(s2); array.add(s3); array.add(s4); array.add(s5); array.add(s6); array.add(s7); // 创建新集合 ArrayList newArray = new ArrayList(); // 遍历旧集合,获取得到每一个元素 Iterator it = array.iterator(); while (it.hasNext()) { Student s = (Student) it.next(); // 拿这个元素到新集合去找，看有没有 if (!newArray.contains(s)) { newArray.add(s); } } // 遍历新集合 for (int x = 0; x < newArray.size(); x++) { Student s = (Student) newArray.get(x); System.out.println(s.getName() + "---" + s.getAge()); } } }
08 set （ set.add("hello"); ）
Collection --List * 有序(存储顺序和取出顺序一致),可重复 --Set 无序(存储顺序和取出顺序不一致),唯一 --HashSet：它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。 * 注意：虽然Set集合的元素无序，但是，作为集合来说，它肯定有它自己的存储顺序， * 而你的顺序恰好和它的存储顺序一致，这代表不了有序，你可以多存储一些数据，就能看到效果。
import java.util.HashSet; import java.util.Set; public class day16_02 { /* * Collection * |--List * 有序(存储顺序和取出顺序一致),可重复 * |--Set * 无序(存储顺序和取出顺序不一致),唯一 * * HashSet：它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。 * 注意：虽然Set集合的元素无序，但是，作为集合来说，它肯定有它自己的存储顺序， * 而你的顺序恰好和它的存储顺序一致，这代表不了有序，你可以多存储一些数据，就能看到效果。 */ public static void main(String[] args) { // 创建集合对象 Set<String> set = new HashSet<String>(); // 创建并添加元素 set.add("hello"); set.add("java"); set.add("world"); set.add("java"); set.add("world"); // 增强for for (String s : set) { System.out.println(s); } } } --------------------- hello java world
08-02 HashSet:存储字符串并遍历，自带去重的操作-------------HashSet底层依赖的是hashCode()和equals()方法。
HashSet:存储字符串并遍历 * 问题：为什么存储字符串的时候，字符串内容相同的只存储了一个呢? * 查看add方法的源码，这个方法底层依赖 两个方法：hashCode()和equals()。 * 步骤： * 首先比较哈希值 * 如果相同，继续走，比较地址值或者走equals() * 如果不同,就直接添加到集合中 * 按照方法的步骤来说： * 先看hashCode()值是否相同 * 相同:继续走equals()方法 * 返回true： 说明元素重复，就不添加 * 返回false：说明元素不重复，就添加到集合 * 不同：就直接把元素添加到集合 * 如果类没有重写这两个方法，默认使用的Object()。 * 而String类重写了hashCode()和equals()方法，所以，它就可以把内容相同的字符串去掉。只留下一个。
import java.util.HashSet; import java.util.Set; public class day16_02 { /* * HashSet:存储字符串并遍历 * 问题：为什么存储字符串的时候，字符串内容相同的只存储了一个呢? * 查看add方法的源码，这个方法底层依赖 两个方法：hashCode()和equals()。 * 步骤： * 首先比较哈希值 * 如果相同，继续走，比较地址值或者走equals() * 如果不同,就直接添加到集合中 * 按照方法的步骤来说： * 先看hashCode()值是否相同 * 相同:继续走equals()方法 * 返回true： 说明元素重复，就不添加 * 返回false：说明元素不重复，就添加到集合 * 不同：就直接把元素添加到集合 * 如果类没有重写这两个方法，默认使用的Object()。 * 而String类重写了hashCode()和equals()方法，所以，它就可以把内容相同的字符串去掉。只留下一个。 */ public static void main(String[] args) { // 创建集合对象 HashSet<String> hs = new HashSet<String>(); // 创建并添加元素 hs.add("hello"); hs.add("world"); hs.add("java"); hs.add("world"); // 遍历集合 for (String s : hs) { System.out.println(s); } } } ----------------- hello java world
08-03 存储自定义对象，并保证元素的唯一性。
需求：存储自定义对象，并保证元素的唯一性 * 要求：如果两个对象的成员变量值都相同，则为同一个元素。 * * 目前是不符合我的要求的：因为我们知道HashSet底层依赖的是hashCode()和equals()方法。 * 而这两个方法我们在学生类中没有重写，所以，默认使用的是Object类。 * 这个时候，他们的哈希值是不会一样的，根本就不会继续判断，执行了添加操作。
所以Student类应该重写hashCode()和equals()方法。
/** * @author Administrator * */ public class Student { private String name; private int age; public Student() { super(); } public Student(String name, int age) { super(); 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 int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Student other = (Student) obj; if (age != other.age) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } // @Override // public int hashCode() { // // return 0; // // 因为成员变量值影响了哈希值，所以我们把成员变量值相加即可 // // return this.name.hashCode() + this.age; // // 看下面 // // s1:name.hashCode()=40,age=30 // // s2:name.hashCode()=20,age=50 // // 尽可能的区分,我们可以把它们乘以一些整数 // return this.name.hashCode() + this.age * 15; // } // // @Override // public boolean equals(Object obj) { // // System.out.println(this + "---" + obj); // if (this == obj) { // return true; // } // // if (!(obj instanceof Student)) { // return false; // } // // Student s = (Student) obj; // return this.name.equals(s.name) && this.age == s.age; // } // // @Override // public String toString() { // return "Student [name=" + name + ", age=" + age + "]"; // } }
import java.util.HashSet; import java.util.Set; public class day16_02 { /* * 需求：存储自定义对象，并保证元素的唯一性 * 要求：如果两个对象的成员变量值都相同，则为同一个元素。 * * 目前是不符合我的要求的：因为我们知道HashSet底层依赖的是hashCode()和equals()方法。 * 而这两个方法我们在学生类中没有重写，所以，默认使用的是Object类。 * 这个时候，他们的哈希值是不会一样的，根本就不会继续判断，执行了添加操作。 */ public static void main(String[] args) { // 创建集合对象 HashSet<Student> hs = new HashSet<Student>(); // 创建学生对象 Student s1 = new Student("林青霞", 27); Student s2 = new Student("柳岩", 22); Student s3 = new Student("王祖贤", 30); Student s4 = new Student("林青霞", 27); Student s5 = new Student("林青霞", 20); Student s6 = new Student("范冰冰", 22); // 添加元素 hs.add(s1); hs.add(s2); hs.add(s3); hs.add(s4); hs.add(s5); hs.add(s6); // 遍历集合 for (Student s : hs) { System.out.println(s.getName() + "---" + s.getAge()); } } }
08-04 HashSet集合存储自定义对象并遍历。
import java.util.HashSet; public class day16_02 { /* * HashSet集合存储自定义对象并遍历。如果对象的成员变量值相同即为同一个对象 * * 注意了： * 你使用的是HashSet集合，这个集合的底层是哈希表结构。 * 而哈希表结构底层依赖:hashCode()和equals()方法。 * 如果你认为对象的成员变量值相同即为同一个对象的话，你就应该重写这两个方法。 * 如何重写呢?不同担心，自动生成即可。 */ public static void main(String[] args) { // 创建集合对象 HashSet<Dog> hs = new HashSet<Dog>(); // 创建狗对象 Dog d1 = new Dog("秦桧", 25, "红色", '男'); Dog d2 = new Dog("高俅", 22, "黑色", '女'); Dog d3 = new Dog("秦桧", 25, "红色", '男'); Dog d4 = new Dog("秦桧", 20, "红色", '女'); Dog d5 = new Dog("魏忠贤", 28, "白色", '男'); Dog d6 = new Dog("李莲英", 23, "黄色", '女'); Dog d7 = new Dog("李莲英", 23, "黄色", '女'); Dog d8 = new Dog("李莲英", 23, "黄色", '男'); // 添加元素 hs.add(d1); hs.add(d2); hs.add(d3); hs.add(d4); hs.add(d5); hs.add(d6); hs.add(d7); hs.add(d8); // 遍历 for (Dog d : hs) { System.out.println(d.getName() + "---" + d.getAge() + "---" + d.getColor() + "---" + d.getSex()); } } } --------------- 魏忠贤---28---白色---男 秦桧---20---红色---女 高俅---22---黑色---女 李莲英---23---黄色---女 李莲英---23---黄色---男 秦桧---25---红色---男
public class Dog{ private String name; private int age; private String color; private char sex; public Dog() { super(); } public Dog(String name, int age, String color, char sex) { super(); this.name = name; this.age = age; this.color = color; this.sex = sex; } 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 getColor() { return color; } public void setColor(String color) { this.color = color; } public char getSex() { return sex; } public void setSex(char sex) { this.sex = sex; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + ((color == null) ? 0 : color.hashCode()); result = prime * result + ((name == null) ? 0 : name.hashCode()); result = prime * result + sex; return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Dog other = (Dog) obj; if (age != other.age) return false; if (color == null) { if (other.color != null) return false; } else if (!color.equals(other.color)) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; if (sex != other.sex) return false; return true; } }
08-05 LinkedHashSet ：底层数据结构由哈希表和链表组成。
* LinkedHashSet:底层数据结构由哈希表和链表组成。 * 哈希表保证元素的唯一性。 * 链表保证元素有素。(存储和取出是一致
import java.util.LinkedHashSet; public class day16_02 { /* * LinkedHashSet:底层数据结构由哈希表和链表组成。 * 哈希表保证元素的唯一性。 * 链表保证元素有素。(存储和取出是一致) */ public static void main(String[] args) { // 创建集合对象 LinkedHashSet<String> hs = new LinkedHashSet<String>(); // 创建并添加元素 hs.add("hello"); hs.add("world"); hs.add("java"); hs.add("world"); hs.add("java"); // 遍历 for (String s : hs) { System.out.println(s); } } } ---------------- hello world java
08-06 TreeSet：能够对元素按照某种规则进行排序。
* TreeSet：能够对元素按照某种规则进行排序。 * 排序有两种方式 * A:自然排序 * B:比较器排序 * * TreeSet集合的特点：排序和唯一 * 通过观察TreeSet的add()方法，我们知道最终要看TreeMap的put()方法。
import java.util.TreeSet; public class day16_02 { /* * TreeSet：能够对元素按照某种规则进行排序。 * 排序有两种方式 * A:自然排序 * B:比较器排序 * * TreeSet集合的特点：排序和唯一 * 通过观察TreeSet的add()方法，我们知道最终要看TreeMap的put()方法。 */ public static void main(String[] args) { // 创建集合对象 // 自然顺序进行排序 TreeSet<Integer> ts = new TreeSet<Integer>(); // 创建元素并添加 // 20,18,23,22,17,24,19,18,24 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); // 遍历 for (Integer i : ts) { System.out.println(i); } } }
/* * 如果一个类的元素要想能够进行自然排序，就必须实现自然排序接口 */ public class Student implements Comparable<Student> { private String name; private int age; public Student() { super(); } public Student(String name, int age) { super(); 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 int compareTo(Student s) { // return 0; // return 1; // return -1; // 这里返回什么，其实应该根据我的排序规则来做 // 按照年龄排序,主要条件 int num = this.age - s.age; // 次要条件 // 年龄相同的时候，还得去看姓名是否也相同 // 如果年龄和姓名都相同，才是同一个元素 int num2 = num == 0 ? this.name.compareTo(s.name) : num; return num2; } }
（2） TreeSet存储自定义对象并保证排序和唯一。
TreeSet存储自定义对象并保证排序和唯一。 * * A:你没有告诉我们怎么排序 * 自然排序，按照年龄从小到大排序 * B:元素什么情况算唯一你也没告诉我 * 成员变量值都相同即为同一个元素
import java.util.TreeSet; public class day16_02 { /* * TreeSet存储自定义对象并保证排序和唯一。 * * A:你没有告诉我们怎么排序 * 自然排序，按照年龄从小到大排序 * B:元素什么情况算唯一你也没告诉我 * 成员变量值都相同即为同一个元素 */ public static void main(String[] args) { // 创建集合对象 TreeSet<Student> ts = new TreeSet<Student>(); // 创建元素 Student s1 = new Student("linqingxia", 27); Student s2 = new Student("zhangguorong", 29); Student s3 = new Student("wanglihong", 23); Student s4 = new Student("linqingxia", 27); Student s5 = new Student("liushishi", 22); Student s6 = new Student("wuqilong", 40); Student s7 = new Student("fengqingy", 22); // 添加元素 ts.add(s1); ts.add(s2); ts.add(s3); ts.add(s4); ts.add(s5); ts.add(s6); ts.add(s7); // 遍历 for (Student s : ts) { System.out.println(s.getName() + "---" + s.getAge()); } } } ------------- fengqingy---22 liushishi---22 wanglihong---23 linqingxia---27 zhangguorong---29 wuqilong---40
/* * 如果一个类的元素要想能够进行自然排序，就必须实现自然排序接口 */ public class Student implements Comparable<Student> { private String name; private int age; public Student() { super(); } public Student(String name, int age) { super(); 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 int compareTo(Student s) { // return 0; // return 1; // return -1; // 这里返回什么，其实应该根据我的排序规则来做 // 按照年龄排序,主要条件 int num = this.age - s.age; // 次要条件 // 年龄相同的时候，还得去看姓名是否也相同 // 如果年龄和姓名都相同，才是同一个元素 int num2 = num == 0 ? this.name.compareTo(s.name) : num; return num2; } }
interface Collection {...} interface Set extends Collection {...} interface NavigableMap { } class TreeMap implements NavigableMap { public V put(K key, V value) { Entry<K,V> t = root; if (t == null) { compare(key, key); // type (and possibly null) check root = new Entry<>(key, value, null); size = 1; modCount++; return null; } int cmp; Entry<K,V> parent; // split comparator and comparable paths Comparator<? super K> cpr = comparator; if (cpr != null) { do { parent = t; cmp = cpr.compare(key, t.key); if (cmp < 0) t = t.left; else if (cmp > 0) t = t.right; else return t.setValue(value); } while (t != null); } else { if (key == null) throw new NullPointerException(); Comparable<? super K> k = (Comparable<? super K>) key; do { parent = t; cmp = k.compareTo(t.key); if (cmp < 0) t = t.left; else if (cmp > 0) t = t.right; else return t.setValue(value); } while (t != null); } Entry<K,V> e = new Entry<>(key, value, parent); if (cmp < 0) parent.left = e; else parent.right = e; fixAfterInsertion(e); size++; modCount++; return null; } } class TreeSet implements Set { private transient NavigableMap<E,Object> m; public TreeSet() { this(new TreeMap<E,Object>()); } public boolean add(E e) { return m.put(e, PRESENT)==null; } } 真正的比较是依赖于元素的compareTo()方法，而这个方法是定义在 Comparable里面的。 所以，你要想重写该方法，就必须是先 Comparable接口。这个接口表示的就是自然排序。
(3) 请按照姓名的长度排序
import java.util.TreeSet; /* * 需求：请按照姓名的长度排序 */ public class day16_02 { public static void main(String[] args) { // 创建集合对象 TreeSet<Student> ts = new TreeSet<Student>(); // 创建元素 Student s1 = new Student("linqingxia", 27); Student s2 = new Student("zhangguorong", 29); Student s3 = new Student("wanglihong", 23); Student s4 = new Student("linqingxia", 27); Student s5 = new Student("liushishi", 22); Student s6 = new Student("wuqilong", 40); Student s7 = new Student("fengqingy", 22); Student s8 = new Student("linqingxia", 29); // 添加元素 ts.add(s1); ts.add(s2); ts.add(s3); ts.add(s4); ts.add(s5); ts.add(s6); ts.add(s7); ts.add(s8); // 遍历 for (Student s : ts) { System.out.println(s.getName() + "---" + s.getAge()); } } }
/* * 如果一个类的元素要想能够进行自然排序，就必须实现自然排序接口 */ public class Student implements Comparable<Student> { private String name; private int age; public Student() { super(); } public Student(String name, int age) { super(); 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 int compareTo(Student s) { // 主要条件 姓名的长度 int num = this.name.length() - s.name.length(); // 姓名的长度相同，不代表姓名的内容相同 int num2 = num == 0 ? this.name.compareTo(s.name) : num; // 姓名的长度和内容相同，不代表年龄相同，所以还得继续判断年龄 int num3 = num2 == 0 ? this.age - s.age : num2; return num3; } }
(3)-02请按照姓名的长度排序
需求：请按照姓名的长度排序 * TreeSet集合保证元素排序和唯一性的原理 * 唯一性：是根据比较的返回是否是0来决定。 * 排序： * A:自然排序(元素具备比较性) * 让元素所属的类实现自然排序接口 Comparable * B:比较器排序(集合具备比较性) * 让集合的构造方法接收一个比较器接口的子类对象 Comparator
import java.util.Comparator; import java.util.TreeSet; /* * 需求：请按照姓名的长度排序 * TreeSet集合保证元素排序和唯一性的原理 * 唯一性：是根据比较的返回是否是0来决定。 * 排序： * A:自然排序(元素具备比较性) * 让元素所属的类实现自然排序接口 Comparable * B:比较器排序(集合具备比较性) * 让集合的构造方法接收一个比较器接口的子类对象 Comparator */ public class day16_01 { public static void main(String[] args) { // 创建集合对象 // TreeSet<Student> ts = new TreeSet<Student>(); //自然排序 // public TreeSet(Comparator comparator) //比较器排序 // TreeSet<Student> ts = new TreeSet<Student>(new MyComparator()); // 如果一个方法的参数是接口，那么真正要的是接口的实现类的对象 // 而匿名内部类就可以实现这个东西 TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() { @Override public int compare(Student s1, Student s2) { // 姓名长度 int num = s1.getName().length() - s2.getName().length(); // 姓名内容 int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num; // 年龄 int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2; return num3; } }); // 创建元素 Student s1 = new Student("linqingxia", 27); Student s2 = new Student("zhangguorong", 29); Student s3 = new Student("wanglihong", 23); Student s4 = new Student("linqingxia", 27); Student s5 = new Student("liushishi", 22); Student s6 = new Student("wuqilong", 40); Student s7 = new Student("fengqingy", 22); Student s8 = new Student("linqingxia", 29); // 添加元素 ts.add(s1); ts.add(s2); ts.add(s3); ts.add(s4); ts.add(s5); ts.add(s6); ts.add(s7); ts.add(s8); // 遍历 for (Student s : ts) { System.out.println(s.getName() + "---" + s.getAge()); } } }
public class Student { private String name; private int age; public Student() { super(); } public Student(String name, int age) { super(); 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; } }
08-07 编写一个程序，获取10个1至20的随机数，要求随机数不能重复。
分析： * A:创建随机数对象 * B:创建一个HashSet集合 * C:判断集合的长度是不是小于10 * 是：就创建一个随机数添加 * 否：不搭理它 * D:遍历HashSet集合
package cn.itcast_08; import cn.itcast_08.String; public class Student { // 姓名 private String name; // 语文成绩 private int chinese; // 数学成绩 private int math; // 英语成绩 private int english; public Student(String name, int chinese, int math, int english) { super(); this.name = name; this.chinese = chinese; this.math = math; this.english = english; } public Student() { super(); } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getChinese() { return chinese; } public void setChinese(int chinese) { this.chinese = chinese; } public int getMath() { return math; } public void setMath(int math) { this.math = math; } public int getEnglish() { return english; } public void setEnglish(int english) { this.english = english; } public int getSum() { return this.chinese + this.math + this.english; } }
import java.util.HashSet; import java.util.Random; /* * 需求：请按照姓名的长度排序 */ public class day16_02 { /* * 编写一个程序，获取10个1至20的随机数，要求随机数不能重复。 * * 分析： * A:创建随机数对象 * B:创建一个HashSet集合 * C:判断集合的长度是不是小于10 * 是：就创建一个随机数添加 * 否：不搭理它 * D:遍历HashSet集合 */ public static void main(String[] args) { // 创建随机数对象 Random r = new Random(); // 创建一个Set集合 HashSet<Integer> ts = new HashSet<Integer>(); // 判断集合的长度是不是小于10 while (ts.size() < 10) { int num = r.nextInt(20) + 1; ts.add(num); } // 遍历Set集合 for (Integer i : ts) { System.out.println(i); } } } ---------- 17 1 16 2 18 5 8 11 14 15
TreeSet 进行 ( 键盘录入5个学生信息 )
键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低输出到控制台 * * 分析： * A:定义学生类 * B:创建一个TreeSet集合 * C:总分从高到底如何实现呢? * D:键盘录入5个学生信息 * E:遍历TreeSet集合
import java.util.Comparator; import java.util.Scanner; import java.util.TreeSet; public class day16_01 { /* * 键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低输出到控制台 * * 分析： * A:定义学生类 * B:创建一个TreeSet集合 * C:总分从高到底如何实现呢? * D:键盘录入5个学生信息 * E:遍历TreeSet集合 */ public static void main(String[] args) { // 创建一个TreeSet集合 TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() { @Override public int compare(Student s1, Student s2) { // 总分从高到低 int num = s2.getSum() - s1.getSum(); // 总分相同的不一定语文相同 int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num; // 总分相同的不一定数序相同 int num3 = num2 == 0 ? s1.getMath() - s2.getMath() : num2; // 总分相同的不一定英语相同 int num4 = num3 == 0 ? s1.getEnglish() - s2.getEnglish() : num3; // 姓名还不一定相同呢 int num5 = num4 == 0 ? s1.getName().compareTo(s2.getName()) : num4; return num5; } }); System.out.println("学生信息录入开始"); // 键盘录入5个学生信息 for (int x = 1; x <= 5; x++) { Scanner sc = new Scanner(System.in); System.out.println("请输入第" + x + "个学生的姓名:"); String name = sc.nextLine(); System.out.println("请输入第" + x + "个学生的语文成绩:"); String chineseString = sc.nextLine(); System.out.println("请输入第" + x + "个学生的数学成绩:"); String mathString = sc.nextLine(); System.out.println("请输入第" + x + "个学生的英语成绩:"); String englishString = sc.nextLine(); // 把数据封装到学生对象中 Student s = new Student(); s.setName(name); s.setChinese(Integer.parseInt(chineseString)); s.setMath(Integer.parseInt(mathString)); s.setEnglish(Integer.parseInt(englishString)); // 把学生对象添加到集合 ts.add(s); } System.out.println("学生信息录入完毕"); System.out.println("学习信息从高到低排序如下："); System.out.println("姓名 语文成绩 数学成绩 英语成绩"); // 遍历集合 for (Student s : ts) { System.out.println(s.getName() + " " + s.getChinese() + " " + s.getMath() + " " + s.getEnglish()); } } }