目录
集合
-
集合概述
-
什么是集合？有什么用?
数组实际上就是一个集合。集合实际上就是一个容器，可以来容纳其他类型的数据。
集合为什么在开发中使用的比较多？
集合是一个容器，是一个载体，可以一次容纳多个对象。在实际开发中，假设连接数据库，数据库当中有10条记录，那么假设把这10条记录查询出来，在java程序中会将10条数据封装成10个java对象，然后将10个java对象放到某一个集合当中，将集合传到前端，然后遍历集合，将一个数据一个数据展现出来。
-
集合不能直接存储基本数据类型，另外集合也不能直接存储java对象，集合当中存储的都是java对象的内存地址。（或者说集合中存储的是引用）
list.add(100);//自动装箱Integer 注意： 集合在java中本身是一个容器，是一个对象。 集合中任何时候存储的都是“引用” 集合中也可以存储集合
-
在java中每一个不同的集合，底层会对应不同的数据结构。往不同的集合中存储元素，等于将数据放到了不同的数据结构当中。数据结构：数据存储的结构就是数据结构。不同的数据结构，数据存储方式不同。例如：数组、二叉树、链表、哈希表······，以上这些都是常见的数据结构。
你往集合c1中放数据，可能是放到数组上了。
你往集合c2中放数据，可能是放到二叉树上了。
需要掌握的：不是精通数据结构。java中已经将数据结构实现了，已经写好了这些常用的集合类，你只需要掌握怎么用。在什么情况下选择哪一种合适的集合去使用即可。
new ArrayList(); //创建一个集合对象，底层是数组。 new LinkedList(); //创建一个集合对象，底层是链表。 new TreeSet(); //创建一个集合对象，底层是二叉树。 -
集合在java JDK 的哪个包下：
java.util.*; 所有的集合类和集合接口都在这个包下。
-
为了更好的掌握集合，最好可以将集合的继承结构图背会！
集合的整个体系是什么样的结构
-
在java中集合分为两大类：
-
一类是单个方式存储元素：
单个方式存储元素，这一类集合中超级父接口：java.util.Collection;
-
一类是以键值对儿的方式存储元素：
以键值对的方式春初元素，这一类集合汇总超级父接口：java.util.Map;
-
-
-
总结重点
- 把集合继承结构图背会
- 把Collection接口中的常用方法测试几遍
- 把迭代器弄明白
- Collection接口中的remove方法和contains方法底层都会调用equals。
-
集合的继承结构图
-
Iterable–Collection
-
Map
-
Collection
-
关于java.util.Collection接口中常用的方法
package Collection; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; /* 关于java.util.Collection接口中常用的方法： 1、Collection中能存放什么元素？ 没有使用“泛型”之前，Collection中可以存放Object的所有子类型，使用了“泛型”之后，Collection中只能存储某个具体的类型。 集合后期我们会学习“泛型”语法，目前先不用管。Collection中什么都能存，只要是Object的子类型就行 注意：集合中 不能直接存储基本数据类型，也不能存储java对象，只是存储java对象的内存地址。 2、Collection中的常用方法： boolean add(Object e) 向集合中添加元素 int size() 获取集合中元素的个数 void clear() 清空集合 boolean contains(Object o) 判断当前集合中是否包含元素o，包含返回true，不包含返回false boolean remove(Object o) 删除集合中的某个元素 boolean isEmpty() 判断集合中元素的个数是否为0 Object[] toArray() 调用这个方法可以把集合转换为数组。——作为了解，使用不多 */ public class CollectionText01 { public static void main(String[] args){ //创建一个集合对象 //Collection c = new Collection(); //接口是抽象的，无法实例化对象 //多态 Collection c = new ArrayList(); //测试Collection接口中的常用方法 c.add(1200); //自动装箱，实际上是放进去了一个对象的内存地址。Integer x = new Integer(1200); c.add(3.14); //自动装箱 c.add(new Object()); c.add(new Student()); c.add(true); //自动装箱 //获取集合中元素的个数 System.out.println("集合中元素的个数："+c.size()); //5 //清空集合 c.clear(); System.out.println("集合中元素的个数："+c.size()); //再向集合中添加元素 c.add("hello"); c.add("world"); c.add("坦克"); c.add("绿帽子"); c.add(1); //判断集合中是否包含“绿帽子” boolean flag = c.contains("绿帽子"); System.out.println(flag); //true boolean flag2 = c.contains("绿帽子2"); System.out.println(flag2); //false System.out.println(c.contains(1)); //true System.out.println("集合中元素的个数："+c.size());//5 //删除集合中的某个元素 c.remove(1); System.out.println("集合中元素的个数："+c.size());//4 //判断集合是否为空（集合中是否存在元素） System.out.println(c.isEmpty()); //false //清空 c.clear(); System.out.println(c.isEmpty()); //true(表示结合中没有元素了) c.add("abc"); c.add("def"); c.add(100); c.add("hello world"); c.add(new Student()); //转换成数组(了解，使用不多) Object[] objs = c.toArray(); for(int i = 0 ; i < objs.length ;i++){ //遍历数组 System.out.println(objs[i]); } } } class Student{ } -
关于集合遍历/迭代的专题
package Collection; //关于集合遍历/迭代的专题（*****重点*****） import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class CollectionText02 { public static void main(String[] args) { //注意：以下讲解的遍历/迭代方式，是所有Collection通用的一种方式，在所有的Collection以及子类中使用。在Map集合中不能使用 //创建集合对象 Collection c = new ArrayList();//后面的集合无所谓，主要是看前面的Collection接口，怎么遍历/迭代。 //添加元素 c.add("abc"); c.add("def"); c.add(100); c.add(new Object()); //对集合Collection进行遍历/迭代 //第一步:获取集合对象的迭代器对象Iterator Iterator it = c.iterator(); //第二步：通过以上获取的迭代器对象开始迭代/遍历集合 /* 以下两个方法是迭代器对象Iterator中的方法： boolean hasNext()如果仍有元素可以迭代，则返回true。 Object next() 返回迭代的下一个元素。 */ //使用while循环代替 while(it.hasNext()){ Object obj = it.next(); System.out.println(obj); } /* boolean hasNext = it.hasNext(); System.out.println(hasNext); if(hasNext) { Object obj = it.next(); System.out.println(obj); } hasNext = it.hasNext(); System.out.println(hasNext); if(hasNext) { Object obj = it.next(); System.out.println(obj); } hasNext = it.hasNext(); System.out.println(hasNext); if(hasNext) { Object obj = it.next(); System.out.println(obj); } hasNext = it.hasNext(); System.out.println(hasNext); if(hasNext) { Object obj = it.next(); System.out.println(obj); } hasNext = it.hasNext(); System.out.println(hasNext); if(hasNext) { Object obj = it.next(); System.out.println(obj); }*/ } }
迭代/遍历
package Collection; import java.util.ArrayList; import java.util.Collection; import java.util.HashSet; import java.util.Iterator; //关于集合的迭代/遍历 public class CollectionText03 { public static void main(String[] args) { //创建集合对象 Collection c1 = new ArrayList(); //ArrayList集合：有序可重复 //添加元素 c1.add(1); c1.add(2); c1.add(3); c1.add(4); c1.add(1); //迭代集合 Iterator it = c1.iterator(); while (it.hasNext()) { //存进去什么类型，取出来还是什么类型的。 Object obj = it.next(); if (obj instanceof Integer) { System.out.println("Integer类型"); } //在输出的时候就会转换成字符串型。因为这里调println会调用toString()方法。 System.out.println(obj); } //HashSet集合：无序不可重复 Collection c2 = new HashSet(); //无序：存进去和取出的顺序不一定相同 //不可重复：存储100，不能再存储100。 c2.add(100); c2.add(200); c2.add(300); c2.add(40); c2.add(50); c2.add(60); c2.add(100);//不报错，但是集合中已经存储了100，这个存储不进去了。 Iterator it2 = c2.iterator(); while(it2.hasNext()) { System.out.println(it2.next()); } } } -
深入Collection集合的contains方法
package Collection; import java.util.ArrayList; import java.util.Collection; /* 深入Collection集合的contains方法： boolean contains(Object o) 判断集合中是否包含某个对象o。如果包含返回true，如果不包含返回false。 contains方法是用来判断集合中是否包含某个元素的方法，那么它底层是怎么判断集合中是否包含某个元素的呢？ 调用了equals方法进行比对。equals方法返回true，就表示集合包含这个元素。 */ public class CollectionText04 { public static void main(String[] args) { //创建集合对象 Collection c = new ArrayList(); //向集合中存储元素 String s1 = new String("abc"); c.add(s1);//放进去一个“abc” String s2 = new String("def"); c.add(s2); //集合中元素的个数 System.out.println("元素的个数是：" + c.size()); //新建的对象String String x = new String("abc"); //c集合中是否包含x ？ System.out.println(c.contains(x));//判断集合中是否存在“abc” // true contains底层调用indexOf方法，indexOf方法底层又调用了equals()方法，比较的是内容。 } }
-
测试contains方法以及remove方法
package Collection; import java.util.ArrayList; import java.util.Collection; /* 测试contains方法 测试remove方法 结论：存放在一个集合中的类型，一定要重写equals方法 */ public class CollectionText05 { public static void main(String[] args) { //创建集合对象 Collection c = new ArrayList(); //创建用户对象 User u1 = new User("jack"); //加入集合 c.add(u1); //判断集合中是否包含u2 User u2 = new User("jack"); //没有重写equals方法之前：c.contains(u2) 就是 u1.contains(u2)，而没有重写过的equals是用 == 比较两个对象的内存地址 //System.out.println(c.contains(u2)); //false //重写equals之后，比较的时候会比较name System.out.println(c.contains(u2)); //true c.remove(u2); //remove底层是调用的equals比较 //如果没有重写equals，则使用Object中的equals判断：u1与u2比较的是内存地址，虽然他们内容相同，但内存地址不同，被认为不同 //重写了equals后 System.out.println(c.size()); Integer x = new Integer(10000); c.add(x); Integer y = new Integer(10000); System.out.println(c.contains(y));//true //Integer类的equals方法重写了 //x.contains(y); ----> true //创建集合对象 Collection cc = new ArrayList(); //创建字符串对象 String s1 = new String("hello"); //加进集合 cc.add(s1); //创建一个新的字符串对象 String s2 = new String("hello"); //删除s2 cc.remove(s2); //集合中元素的个数？ System.out.println(cc.size()); //0 } } class User{ private String name; public User(){} public User(String name){ this.name = name; } //重写equals方法 //将来调用equals方法的时候，一定是调用这个重写的equals方法。这个equals方法的比较原理：只要姓名一样，就表示同一个用户 public boolean equals(Object o){ if(o == null || !(o instanceof User)) return false; if(o == this) return true; User u = (User)o; //如果名字一样表示同一个人。（不再比较对象的内存地址了，比较内容） return u.name.equals(this.name); } } -
集合元素的reomve方法，以及迭代器删除原理
package Collection; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; /* 关于集合元素的remove方法 重点：当集合的结构发生改变时，迭代器必须重新获取，如果还是用之前的老迭代器，会出现 异常：java.util.ConcurrentModificationException 重点：在迭代集合元素的过程中，不能调用集合对象的remove方法，删除元素：c.remove(obj); ， 迭代过程中不能这样删除。会出现异常：java.util.ConcurrentModificationException 重点：在迭代运算的过程中，一定要使用迭代器Iterator的remove方法删除元素。不要使用集合自带的remove方法删除元素 */ public class CollectionText06 { public static void main(String[] args) { //创建集合 Collection c = new ArrayList(); //注意：此时获取的迭代器，指向的是集合中没有元素状态下的迭代器。 //一定要注意：集合结构只要发生改变，迭代器必须重新获取 //Iterator it = c.iterator(); //当集合结构发生了改变，迭代器没有重新获取时，调用next()方法时，会出现异常：java.util.ConcurrentModificationException //添加元素 c.add(1); c.add(2); //集合结构发生改变，只要迭代器不是最新的，就会出现异常 //Iterator it = c.iterator(); c.add(3); //获取迭代器 Iterator it = c.iterator(); while(it.hasNext()){ //编写代码时next()方法返回值类型必须是Object //Integer i = it.next(); Object obj = it.next(); System.out.println(obj); } Collection c2 = new ArrayList(); c2.add("abc"); c2.add("def"); c2.add("xyz"); Iterator it2 = c2.iterator(); while(it2.hasNext()){ Object obj = it2.next(); //删除元素 //删除元素之后，集合的结构发生了变化，应该重新去获取迭代器。 // 但是，循环的下一次并不会去自动获取迭代器，所以会出现异常：java.util.ConcurrentModificationException //出异常的根本原因：集合中元素删除了，但是没有更新迭代器。（迭代器不知道集合变化了） //c2.remove(obj); //直接通过集合去删除元素，没有通知迭代器。（导致迭代器的快照和原集合状态不同） //使用迭代器来删除可以吗？ //迭代器去删除时，会自动更新迭代器，并且更新集合（删除集合中的元素） it2.remove(); //删除的一定是迭代器指向的当前元素。 System.out.println(obj); } System.out.println(c2.size()); //0 } }
List
-
List接口中的常用方法
package Collection; import java.util.ArrayList; import java.util.Iterator; import java.util.List; /* 测试List接口中常用方法： 1、List集合存储元素的特点：有序可重复。 有序：List集合中的元素有下标。从0开始，以1递增 可重复：存储一个1，还可以存储1. 2、List既然是Collection接口的子接口，那么肯定List接口有自己“特色”的方法： 以下只列出List接口特有的常用的方法： void add(int index , Object element) Object set(int index , Object element) Object get(int index) int indexOf(Object o) int LastIndexOf(Object o) Object remove(int index) 以上方法不需要死记硬背，可以自己测试，理解。以后开发时，还是要翻阅帮助文档 */ /* 计算机英语： 增删改查这几个单词要知道： 增：add、save、new 删：delete、drop、remove 改：update、set、modify 查：find、get、query、select */ public class ListText01 { public static void main(String[] args) { //创建List类型的集合 // List myList = new LikedList(); // List myList = new Vector(); List myList = new ArrayList(); //添加元素 myList.add("A"); //默认都是向集合末尾添加元素 myList.add("B"); myList.add("C"); myList.add("C"); myList.add("D"); //在列表的指定位置插入指定元素（第一个参数是下标） //这个方法使用不多，因为对于ArrayList集合来说效率比较低 myList.add(1,"KING"); //迭代 Iterator it = myList.iterator(); while (it.hasNext()){ Object obj = it.next(); System.out.println(obj); } //根据下标获取元素 Object firstObj = myList.get(0); System.out.println(firstObj); //因为有下标，所以List集合有自己比较特殊的遍历方式。 //通过下标遍历【List集合特有的，Set没有】 for(int i = 0 ; i <myList.size() ; i++){ System.out.println(myList.get(i)); } //获取指定对象第一次出现处的索引 System.out.println(myList.indexOf("KING"));//1 //获取指定对象最后一次出现处的索引 System.out.println(myList.lastIndexOf("C"));//4 //删除指定下标位置的元素 //删除下标为0的元素 myList.remove(0); System.out.println(myList.size());//5 System.out.println("= = = = = = = = = = = = = = = = = = == = = = ="); //修改指定位置的元素 myList.set(2,"shen"); //遍历集合 for(int i = 0 ; i < myList.size() ; i++){ System.out.println(myList.get(i)); } } } -
ArrayList集合
package Collection; import java.util.ArrayList; import java.util.List; /* ArrayList集合： 1、ArrayList集合是非线程安全的。 2、默认初始化容量：10。（当你添加第一个元素的时候，默认初始化容量为10） 3、集合底层是一个Object[] 数组 4、构造方法： new ArrayList(); new ArrayList(20); 5、ArrayList集合的扩容： 增长到原容量的1.5倍。 ArrayList集合底层是数组，怎么优化？ 尽可能少的扩容，因为数组扩容的效率比较低，建议在使用ArrayList集合的时候预估计元素的个数，给定一个初始化容量 6、数组优点： 检索效率比较高。（每个元素占用空间大小相同，内存地址是连续的，知道首元素的内存地址，知道下标， 通过数学表达式计算出元素的内存地址，所以检索效率高） 7、数组缺点： 随机增删元素效率比较低。 另外数组无法存储大数据量。（很难找到一块巨大的连续的内存空间） 8、向数组末尾添加元素，效率不受影响。 （向空盒子中添加元素的效率高，有专门的式子可以算出没有存放内容的内存地址，直接存放进去。） （而从一个里面拿出来放入另一个，即扩容的效率就比较低） 9、面试官经常问的一个问题 这么多的集合中，用哪个集合最多？ ArrayList集合 因为往数组末尾添加元素，效率不受影响。另外，我们检索/查找某个元素的操作比较多。 */ public class ArrayListText01 { public static void main(String[] args) { //默认初始化容量：10，数组的长度：10 List list1 = new ArrayList(); //集合的size()方法时获取当前集合中元素的个数，而不是获取集合的容量 System.out.println(list1.size());//0 //指定初始化容量，数组的长度：20 List list2 = new ArrayList(20); //集合的size()方法时获取当前集合中元素的个数，而不是获取集合的容量 System.out.println(list2.size());//0 list1.add(1); list1.add(2); list1.add(3); list1.add(4); list1.add(5); list1.add(6); list1.add(7); list1.add(8); list1.add(9); list1.add(10); System.out.println(list1.size()); //再添加一个元素 list1.add(11); System.out.println(list1.size()); //11个元素 /* int newCapacity = ArraysSupport.newLength(oldCapacity,minCapacity - oldCapacity,oldCapacity >> 1) 100二进制转换成十进制：0000 0100 右移一位：0000 0010（2），【4/2】 原先是4，现在增长：2，增长之后是6。增长之后的容量是之前的1.5倍。 //6是4的1.5倍 */ } }位运算符
package Collection; /* 位运算符 右移：>> 左移：<< */ public class BinaryText { public static void main(String[] args) { // >> 1 二进制右移1位 // >> 2 二进制右移2位 // 10的二进制: 0000 1010【10】 // 10的二进制右移一位: 0000 0101【5】 System.out.println(10 >> 1); //5 右移一位就是：/2（÷2），10除2。 //二进制左移1位 //10 的二进制位是：0000 1010 【10】 // 左移一位：0001 0100 【20】 System.out.println(10 << 1); //20 左移一位就是：*2。 System.out.println(111 >> 1); } }集合ArrayList的构造方法
package Collection; import java.util.ArrayList; import java.util.Collection; import java.util.HashSet; import java.util.List; //集合ArrayList的构造方法 public class ArrayListText02 { public static void main(String[] args) { //默认初始化容量10 List myList1 = new ArrayList(); //指定初始化容量20 List myList2 = new ArrayList(); //创建一个HashSet集合 Collection c = new HashSet(); //添加元素到Set集合 c.add(100); c.add(200); c.add(300); c.add(50); //通过这个构造方法就可以将HashSet集合转换成List集合 List myList3 = new ArrayList(c); for(int i = 0 ; i < myList3.size() ; i++){ System.out.println(myList3.get(i)); } } } -
单向链表
单链中的节点
package danlink; /* 单链表中的节点： 节点是单向链表中基本的单元 每一个节点Node都有两个属性： 一个属性：存放的是数据 另一个属性：是下一个节点的内存地址。 */ public class Node { //存储的数据 Object data; //下一个节点的内存地址 Node next; public Node(){ } public Node(Object data,Node next){ this.data = data; this.next = next; } }链表类
package danlink; //链表类 public class Link<E> { public static void main(String[] args){ Link<String> Link = new Link<>(); Link.add("abc"); //类型不匹配 //Link.add(12); } //头节点 Node header = null; int size = 0; public int size(){ return size; } //向链表中添加元素的方法(向末尾添加) //public void add(Object obj){ public void add(E obj){ //创建一个节点对象 //让之前单链表的末尾节点next指向新节点对象 //有可能这个元素是第一个，也可能是第二个，也可能是第三个。 if(header == null){ //说明还没有节点。new一个节点对象，作为头节点对象。 //这个时候的头节点既是一个头节点，又是一个末尾节点。 header = new Node(new Object(),null); }else { //说明头不是空！头节点已经存在了。 //找出当前的末尾节点，让当前末尾节点的next是新节点 Node currentLastNode = findLast(header); currentLastNode.next = new Node(new Object(),null); } size++; } /** * 专门查找末尾节点的方法 * @param node * @return */ private Node findLast(Node node) { if(node.next == null){ //如果一个节点的next是null，说明这个节点就是末尾节点 return node; } //程序可以运行到这里说明：node不是末尾节点。 return findLast(node.next); //递归算法 } //删除链表中元素的方法 public void remove(Object obj){ } //修改链表中某个元素的方法 public void modify(Object newObj){ } //查找链表中某个元素的方法 public int find(Object obj){ return 1; } }测试
package danlink; public class LinkText { public static void main(String[] args) { //创建一个集合对象 Link link = new Link(); //往集合中添加元素 link.add("abc"); link.add("def"); link.add("xyz"); //获取元素个数 System.out.println(link.size()); } } -
链表的优缺点
package Collection; import java.util.ArrayList; import java.util.LinkedList; import java.util.List; /* 链表的优点： 由于链表上的元素在空间存储上的内存地址不连续。所以随机增删元素的时候不会有大量元素位移，因此随机增删效率较高， 在以后的开发中，如果遇到随机增删集合中元素的业务比较多时，建议使用LinkedList。 链表的缺点： 不能通过数学表达式计算被查找元素的内存地址，每一次查找都是从头节点开始遍历，直到找到为止。 所以LinkedList集合检索/查找的效率较低 ArrayList：把检索发挥到极致。（末尾添加元素效率还是很高的。） LinkedList：把随机增删发挥到极致。 加元素都是往末尾添加，所以ArrayList用的比LinkedList多。 */ public class LinkedListText01 { public static void main(String[] args) { //LinkedList集合底层也是有下标的。 //注意：ArrayList之所以检索效率比较高，不是单纯因为下标的原因，是因为底层数组发挥的作用。 //LinkedList集合照样有下标，但是检索/查找某个元素的时候效率比较低，因为只能从头节点开始一个一个遍历 List list = new LinkedList(); list.add("a"); list.add("b"); list.add("c"); for(int i = 0 ; i < list.size() ; i++){ System.out.println(list.get(i)); } /* LinkedList集合有初始化容量吗？ 没有，最初这个链表中没有任何元素。first和last引用都是null。 不管是LinkedList还是ArrayList，以后写代码时不需要关心具体是哪个集合。因为我们要面向接口编程，调用的方法都是接口中的方法 */ //List list2 = new ArrayList();//这样写表示底层用了数组 List list2 = new LinkedList(); //这样写表示底层用了双向链表 //以下这些方法都素面向的都是接口编程。 list2.add("123"); list2.add("456"); list2.add("789"); for(int i = 0 ; i < list2.size(); i++){ System.out.println(list2.get(i)); } } }内存图
双向链表
-
Vectror
package Collection; import java.util.*; /* Vector : 1、底层也是一个数组。 2、初始化容量：10 3、怎么扩容的？ 扩容之后是原容量的2倍。 10 --> 20 --> 30 --> 40 4、ArrayList集合扩容特点： ArrayList集合扩容是原容量的1.5倍 5、Vector中所有的方法都是线程安全的，都带有synchronized关键字，是线程安全的，效率比较低，使用较少了 6、怎么将一个非线程安全的ArrayList集合转换成线程安全的呢？ 使用集合工具类： java.util.Collections; java.util.Collection 是集合接口 java.util.Collections 是集合工具类 */ public class VectorText { public static void main(String[] args) { //创建一个Vector集合 Vector vector = new Vector(); //添加元素 //默认容量10 vector.add(1); vector.add(2); vector.add(3); vector.add(4); vector.add(5); vector.add(6); vector.add(7); vector.add(8); vector.add(9); vector.add(10); //满了之后扩容（扩容之后的容量是20） vector.add(11); //遍历 Iterator it = vector.iterator(); while (it.hasNext()){ System.out.println(it.next()); } //将ArrayList集合转换成线程安全 //这个可能以后要使用： List myList = new ArrayList(); //非线程安全的 //变成线程安全的 Collections.synchronizedList(myList);//这里没有办法看效果，因为多线程没有学，先记住！ //myList集合就是线程安全的了 myList.add("111"); myList.add("222"); myList.add("333"); } }
泛型
-
泛型是什么，泛型的好处以及缺点
package Collection; import java.util.ArrayList; import java.util.Iterator; import java.util.List; /* 1、JDK5.0之后推出的新特性：泛型。 2、泛型这种语法机制，只在程序的编译阶段起作用，只是给编译器参考的。（运行阶段泛型没用） 3、使用了泛型好处是什么？ 第一：集合中存储的元素类型统一了 第二：从集合中取出的元素类型是泛型指定的类型，不需要进行大量的“向下转型”。 4、泛型的缺点： 导致集合中存储的元素缺乏多样性！ 大多数业务中，集合中元素的类型还是统一的。所以这种泛型特性被大家所认可。 */ public class GenericText01 { public static void main(String[] args) { //不使用泛型机制，分析程序存在的缺点 /*List myList = new ArrayList(); //准备对象 Cat c = new Cat(); Bird b = new Bird(); //将对象添加到集合当中 myList.add(c); myList.add(b); //遍历集合，取出每个Animal，让他move Iterator it = myList.iterator(); while (it.hasNext()){ //没有这个语法，通过迭代器取出来的就是Object类型的对象 //Animal a = it.next(); Object obj = it.next(); //obj中没有move方法，无法调用，需要向下转型 if(obj instanceof Animal){ Animal a = (Animal)obj; a.move(); } }*/ //使用JDK5之后的泛型机制 //使用泛型List<Animal> 之后，表示List集合中只允许存储Animal类型的数据 //用泛型来指定集合中存储的数据类型。 List<Animal> myList = new ArrayList<Animal>(); //指定List集合中只能存储Animal，那么存储String就编译报错了。 //这样用了泛型之后，集合中元素的数据类型更加统一了。 //myList.add("111"); Cat c = new Cat(); Bird b = new Bird(); myList.add(c); myList.add(b); //获取迭代器。 //这个表示迭代器迭代的是Animal类型 Iterator<Animal> it = myList.iterator(); while(it.hasNext()){ //使用泛型之后，每一次迭代返回的数据都是Animal类型 Animal a = it.next(); //这里不需要进行强制类型转换了，直接调用 //a.move(); //调用子类型特有的方法还是需要向下转换的！ if(a instanceof Cat){ Cat cc = (Cat)a; cc.catchMouse(); }else if(a instanceof Bird){ Bird bb = (Bird)a; bb.fly(); } } } } class Animal{ //父类自带方法 public void move(){ System.out.println("动物在移动"); } } class Cat extends Animal{ //特有方法 public void catchMouse(){ System.out.println("猫抓老鼠"); } } class Bird extends Animal{ //特有方法 public void fly(){ System.out.println("鸟儿在飞"); } } -
泛型的自动推断机制（又称为：钻石表达式）
package Collection; import java.util.ArrayList; import java.util.Iterator; import java.util.List; /* JDK8之后引入了自动类型推断机制（又称为：钻石表达式） */ public class GenericText02 { public static void main(String[] args){ //ArrayList<这里的类型会自动推断>()，前提是JDK8之后才允许。 //自动类型推断，钻石表达式！ List<Animal> myList = new ArrayList<>(); myList.add(new Animal()); myList.add(new Cat()); myList.add(new Bird()); //遍历 Iterator<Animal> it = myList.iterator(); while (it.hasNext()){ Animal a = it.next(); a.move(); } List<String> strList = new ArrayList<>(); //类型不匹配 //strList.add(new Cat()); //strList.add(10); strList.add("http://www.baidu.com"); strList.add("http://www.hao123.com"); strList.add("http://www.12306.com"); //System.out.println(strList.size()); //遍历 Iterator<String> it2 = strList.iterator(); while(it2.hasNext()){ //如果没有使用泛型 /* Object obj = it2.next(); if(obj instanceof String){ String ss = (String)obj; ss.substring(7); }*/ //直接通过迭代器获取了String类型的数据 String s = it2.next(); //直接调用String类的substring方法截取字符串。 String newString = s.substring(7); System.out.println(newString); } } } -
可自定义泛型
package Collection; /* 可以自定义泛型 自定义泛型的时候，<>尖括号中的是一个标识符，可以随便写 java源代码中经常出现的是： <E>和<T> E：Element的首字母 T：Type的首字母 */ public class GenericText03<标识符随便写> { public void doSome(标识符随便写 o){ System.out.println(o); } public static void main(String[] args) { //new对象的时候指定了泛型是：String类型 GenericText03<String> gt = new GenericText03<>(); //类型不匹配 //gt.doSome(10); gt.doSome("123"); System.out.println("---------------------------------------------------"); GenericText03<Integer> gt2 = new GenericText03<>(); gt2.doSome(1); //类型不匹配 //gt2.doSome("12"); //不用泛型，则是Object类型 //GenericText03 gt3 = new GenericText03(); //gt3.doSome(new Object()); MyIterator<String> mi1 = new MyIterator<>(); String s = mi1.get(); MyIterator<Integer> mi2 = new MyIterator<>(); Integer i = mi2.get(); } } class MyIterator<T>{ public T get(){ return null; } }
增强for（foreach）
-
foreach是什么、foreach 的缺点
package Collection; /* JDK5.0之后推出了一个新特性：叫做增强for循环，或者叫：foreach foreach有一个缺点； 没有下标：在需要使用下标的循环中，不建议使用增强for(foreach) */ public class ForEachText01 { public static void main(String[] args) { //int类型数组 int[] arr = {21,34,54,34,43,44,29}; //遍历数组（普通for循环） for(int i = 0; i <arr.length ; i++){ System.out.println(arr[i]); } System.out.println("=================================================="); //增强for（foreach） //以下是语法 /* for(元素类型 变量名 : 数组或集合){ System.out.println(变量名); }*/ for(int data : arr){ //data就是数组中元素（数组中的每一个元素） System.out.println(data); } } } -
集合使用foreach
package Collection; import java.util.ArrayList; import java.util.Iterator; import java.util.List; /* 集合使用foreach */ public class ForeachText02 { public static void main(String[] args) { //创建List集合 List<String> strList = new ArrayList<>(); //添加元素 strList.add("hello"); strList.add("world"); strList.add("Kitty"); //使用迭代器遍历 Iterator<String> it = strList.iterator(); while(it.hasNext()){ String s = it.next(); System.out.println(s); } //使用下标的方式（只针对有下标的集合） for(int i = 0 ; i<strList.size();i++){ System.out.println(strList.get(i)); } System.out.println("================================================="); //使用foreach for(String s :strList){ //因为泛型使用的是String类型，所以是：String s System.out.println(s); } List<Integer> li = new ArrayList<>(); li.add(12); li.add(13); li.add(14); for(Integer i : li){ //i代表集合中的元素 System.out.println(i); } } }
Set简述
-
HashSet简述
package Collection; import java.util.HashSet; import java.util.Set; /* HashSet集合： 无序不可重复 */ public class HashSetText01 { public static void main(String[] args) { //演示一下HashSet集合特点 Set<String> strs = new HashSet<>(); //添加元素 strs.add("hello"); strs.add("hello2"); strs.add("hello3"); strs.add("hello4"); strs.add("hello6"); strs.add("hello7"); strs.add("hello"); strs.add("hello"); strs.add("hello"); strs.add("hello"); //遍历 for(String s : strs){ System.out.println(s); } /* hello4 hello2 hello hello3 hello6 hello7 1、存储时顺序和取出的顺序不同 2、不可重复 3、放到HashSet集合中的元素实际上是放到了HashMap集合的key部分了 */ } } -
TreeSet简述
package Collection; import java.util.Set; import java.util.TreeSet; /* TreeSet集合存储元素的特点： 1、无序不可重复的，但是存储的元素可以自动按照大小顺序排序！ 称为：可排序集合 2、无序：这里的无序指的是存进去的顺序和取出来的顺序不同，并且没有下标。 */ public class TreeSetText01 { public static void main(String[] args) { //创建集合对象 Set<String> strs = new TreeSet<>(); //添加元素 strs.add("A"); strs.add("C"); strs.add("E"); strs.add("G"); strs.add("S"); strs.add("Y"); strs.add("C"); //遍历 for(String s : strs){ System.out.println(s); } /* A C E G S Y 从小到大自动排序 */ } }
Map
-
java.util.Map接口中常用的方法：
package Map; import java.util.Collection; import java.util.HashMap; import java.util.Map; /* java.util.Map接口中常用的方法： 1、Map和Collection没有继承关系 2、Map集合以key和value的方式存储数据：键值对 key和value都是引用数据类型 key和value都是存储对象的内存地址。 key起到主导地位，value是key的一个附属品 3、Map接口中常用的方法： V put(K key , V value) 向Map集合中添加键值对 V get(Object key) 通过key获取value void clear() 清空Map集合 boolean containsKey(Object key) 判断Map集合中是否包含某个key boolean containsValue(Object value) 判断Map集合中是否包含某个value boolean isEmpty() 判断Map中元素个数是否为0 V remove(Object key) 通过key删除键值对 int size() 获取Map集合中键值对的个数 Collection<V> values() 获取Map集合中所有的value，返回一个Collection Set<K> keySet() 获取Map集合中所有的key（所有的键是一个Set集合） Set<Map.Entry<K,V>> entrySet() 将Map集合转换成Set集合 假设现在有一个Map集合 假设现在有一个Map集合，如下所示： map1集合 key value ------------------------------------- 1 zhangsan 2 lisi 3 wangwu 4 zhaoliu Set set = map1.entrySet(); 注意：Map集合通过entrySet()方法转成的这个Set集合，Set集合中元素的类型是：Map.Entry<K,V> Map.Entry和String一样，都是一种类型的名字，只不过：Map.Entry是静态内部类，是Map中的静态内部类 set集合对象 1 = zhangsan 2 = lisi 3 = wangwu 4 = zhaoliu ----> 这个东西是什么？ Map.Entry */ public class MapText01 { public static void main(String[] args) { //创建Map集合对象 Map<Integer ,String> map = new HashMap<>(); //向Map集合中添加键值对 map.put(1,"zhangsan"); //1在这里进行了自动装箱 map.put(2,"lisi"); map.put(3,"wangwu"); map.put(4,"zhaoliu"); //通过key获取value String value = map.get(1); System.out.println(value); //获取键值对的数量 System.out.println("几对键值对："+map.size()); //通过key删除键值对 map.remove(2); System.out.println("几对键值对："+map.size()); //contains方法底层调用的都是equals进行比对的，所以自定义的类型需要重写equals方法 //判断是否包含某个key //这里即使是new了一个新对象，也是true System.out.println(map.containsKey(new Integer(4)));//true //判断是否包含某个value System.out.println(map.containsValue("zhangsan")); //true //获取所有的value Collection<String> values = map.values(); //foreach for (String s :values){ System.out.println("-----"+s); } //清空map集合 map.clear(); System.out.println("清空键值对后数量："+map.size()); //判断map集合是否为空 System.out.println(map.isEmpty()); //true:表示为空 } }静态内部类
package Map; import java.util.HashSet; import java.util.Set; //静态内部类 public class MyClass { //声明一个静态内部类 public static class InnerClass{ //静态方法 public static void m1(){ System.out.println("静态内部类中的m1方法执行"); } //实例方法 public void m2(){ System.out.println("静态内部类中的实力方法执行了"); } } public static void main(String[] args) { //类名叫做：MyClass.InnerClass MyClass.InnerClass.m1(); //创建静态内部类对象 MyClass.InnerClass mic = new MyClass.InnerClass(); mic.m2(); //给一个Set集合 //该Set集合中存储的对象是MyClass.InnerClass类型 Set<MyClass.InnerClass> set = new HashSet<>(); //这个Set集合中存储的是字符串对象 Set<String> set2 = new HashSet<>(); Set<MyMap.MyEntry<Integer,String>> set3 = new HashSet<>(); } } class MyMap { public static class MyEntry<k,v>{ } } -
Map集合的遍历
package Map; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; /* Map集合的遍历 */ public class MapText02 { public static void main(String[] args) { Map<Integer,String> map = new HashMap<>(); map.put(1,"zhangsan"); map.put(2,"lisi"); map.put(3,"wangwu"); map.put(4,"zhaoliu"); //遍历map集合 //第一种方式：获取所有的key，通过遍历key，来遍历value //获取所有的key，所有的key是一个Set集合 Set<Integer> keys =map.keySet(); //遍历key，通过key获取value //迭代器遍历 Iterator<Integer> it = keys.iterator(); while(it.hasNext()){ //取出其中一个key Integer key = it.next(); //通过key获取value String value = map.get(key); System.out.println(key+"="+value); } //foreach 遍历 for(Integer key : keys){ System.out.println(key+"="+map.get(key)); } System.out.println("--------------------------------------------------------"); //第二种方式：Set<Map.Entry<K,V>> entrySet() //以上这种方法是把Map集合直接全部转换成Set集合 Set集合中的元素类型：Map.Entry Set<Map.Entry<Integer,String>> set = map.entrySet(); //遍历Set集合，每一次取出一个Node //迭代器 Iterator<Map.Entry<Integer,String>> it2 = set.iterator(); while (it2.hasNext()){ Map.Entry<Integer,String> node = it2.next(); Integer key = node.getKey(); String value = node.getValue(); System.out.println(key+"="+value); } //foreach //这种方式效率比较高，因为获取key和value都是直接从node对象中获取的属性值。这种方式比较适合于大数据量 for(Map.Entry<Integer,String> node : set){ System.out.println(node.getKey() + "=" +node.getValue()); } } } -
HashMap
package Map; import java.util.HashMap; import java.util.Map; import java.util.Set; /* HashMap集合： 1、HashMap集合底层是哈希表/散列表的数据结构。 2、哈希表是一个怎样的数据结构呢？ 哈希表是要给数组和单向链表的结合体 数组：在查询方面效率很高，随机增删方面效率很低 单向链表：在随机增删方面效率高，在查询方面效率低 哈希表将以上的两种数据结构融合到一起，充分发挥他们各自的优点。 3、HashMap集合底层的源代码： public class HashMap{ //HashMap底层实际上就是一个数组。（一维数组） Node<K,V>[] table; //静态的内部类HashMap.Node static class Node<K,V> { final int hash; //哈希值（哈希值是key的hashCode()方法的执行结果。hash值通过哈希函数/算法，可以转换存储成数组下标。） final K key; //存储到Map集合中的那个key V value; //存储到Map集合中的那个value Node<K,V> next; //下一个节点的内存地址 } } 哈希表/散列表：一维数组，这个数组中每一个元素是一个单向链表（数组和链表的结合体） 4、最主要掌握的是： map.put(k,v) v = map.get(k) 以上两个方法的实现原理，是必须掌握的 5、HashMap集合key部分的特点： 无序、不可重复 为什么无序？因为不一定挂到哪个单向链表上。 不可重复是怎么保证的？equals方法来保证HashMap集合的key不可重复。如果key重复了，value会覆盖 放在HashMap集合key部分的元素其实就是放到HashSet集合中了 所以HashSet集合中的元素也需要同时重写hashCode()与equals()方法 6、哈希表HashMap使用不当时无法发挥性能！ 假设hashCode()方法返回的而所有值固定为某个值，那么会导致底层哈希表变成了纯单向链表。这种情况我们称为：散列分布不均匀 假设hashCode()方法返回的所有值都不一样，可以吗？有什么问题？ 不行，因为这样的话导致底层哈希表就成为了一维数组了，没有链表的概念了。也就是散列分布不均匀 什么是散列分布均匀？ 假设有100个元素，10个单向链表，那么每个单向链表上有10个节点，这是最好的。是散列分布均匀的。 散列分布均匀需要在重写hashCode()方法时有一定的技巧。 7、重点：放在HashMap集合key部分的元素，以及放在HashSet集合中的元素，需要同时重写hashCode()和equals()方法。 8、HashMap集合的默认初始化容量是16，默认加载因子是0.75. 这个默认加载因子是当HashMap集合底层数组的容量达到75%的时候，数组开始扩容。 重点：记住：HashMap集合初始化容量必须是2的倍数，这也是官方推荐的。 这是因为达到散列分布，为了提高HashMap集合的存取效率，所必须的 9、 */ public class HashMapText01 { public static void main(String[] args) { //测试HashMap集合key部分的元素特点 //Integer是key，它的hashCode和equals都重写了 Map<Integer,String> map = new HashMap<>(); map.put(1111,"zhangsan"); map.put(6666,"lisi"); map.put(7777,"wangwu"); map.put(2222,"zhaoliu"); map.put(6666,"KING"); //key重复的时候，value会自动覆盖。 System.out.println(map.size()); //4 //遍历Map集合 Set<Map.Entry<Integer,String>> set = map.entrySet(); for(Map.Entry<Integer,String> entry : set){ //验证结果：HashMap集合key部分元素：无序不可重复 System.out.println(entry.getKey() + "=" +entry.getValue()); /* 7777=wangwu 1111=zhangsan 6666=KING 2222=zhaoliu */ } } }哈希表数据结构
-
放在HashMap集合key部分的，以及放在HashSet集合中的元素，需要同时重写hashCode方法和equals方法
Student类
package bean; import java.util.Objects; public class Student { private String name; public Student(){ } public Student(String name){ this.name = name; } public String getName(){ return name; } public void setName(String name){ this.name = name; } //hashCode @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Student student = (Student) o; return Objects.equals(name, student.name); } @Override public int hashCode() { return Objects.hash(name); } //equals /* public boolean equals(Object obj){ if(obj == null || !(obj instanceof Student)) return false; if(obj == this) return true; Student s = (Student)obj; return this.name.equals(s.name); }*/ }测试类
package Collection; import bean.Student; import java.util.HashSet; import java.util.Set; /* 1、向Map集合中存，以及从Map集合中取，都是先调用key的hashCode方法，然后再调用equals方法！ equals方法有可能调用，也有可能不调用。拿put(k,v)以及get(k)举例，什么时候equals不会调用？ k.hashCode()方法返回哈希值，哈希值经过哈希算法转换成数组下标。数组下标位置上如果是null，equals不需要执行 2、注意：如果一个类的equals方法重写了，那么hashCode()方法必须重写，并且equals方法如果是true，hashCode()方法返回的值必须一样 equals方法返回true表示两个对象相同，在同一个单向链表上比较。那么对于同一个单向链表上的节点来说：他们的哈希值都是相同的 所以hashCode()方法的返回值也应该相同 3、hashCode()方法和equals()方法不用研究了，直接使用IDEA工具生成，但是这两个方法需要同时生成 4、终极结论： 放在HashMap集合key部分的，以及放在HashSet集合中的元素，需要同时重写hashCode方法和equals方法 5、对于哈希表数据结构来说： 如果o1和02的哈希值相同，一定是放到同一个单向链表上 当然如果o1和02的哈希值不同，但由于哈希算法执行结束后之后转换的数组下标可能相同，此时会发生“哈希碰撞” */ public class HashMapText02 { public static void main(String[] args) { Student s1 = new Student("zhangsan"); Student s2 = new Student("zhangsan"); //重写equals方法之前是false //System.out.println(s1.equals(s2)); false //重写equals方法之后 System.out.println(s1.equals(s2)); //true 表示：s1和s2相等 System.out.println("s1的hashCode="+s1.hashCode()); System.out.println("s2的hashCode="+s2.hashCode()); //s1.equals(s2)结果已经是true了，表示s1和s2是相同的，那么往HashSet集合中放的话，按说只能放一个(HashSet集合特点：无序不可重复) Set<Student> students = new HashSet<>(); students.add(s1);//460141958 （重写hashCode之后：-1432604525） students.add(s2);//1163157884 （重写hashCode之后：-1432604525） System.out.println(students.size()); //这个结果按说应该是1。但结果是2，显然不符合HashSet集合存储特点 } } -
HashMap集合key部分允许null
package Collection; import java.util.HashMap; import java.util.Map; /* HashMap集合key部分允许null吗？ 允许 但是要注意；HashMap集合的key，null值只能有一个 有可能面试的时候会遇到这样的问题 */ public class HashMapText03 { public static void main(String[] args) { Map map = new HashMap(); //HashMap集合允许key为null map.put(null,null); System.out.println(map.size()); //1 //key重复的话value会自动覆盖 map.put(null,102); System.out.println(map.size()); //1 //通过key获取value System.out.println(map.get(null));//102 } } -
Hashtable的key和value都是不能为null的
package Collection; import java.util.Hashtable; import java.util.Map; /* Hashtable的key可以为null吗？ Hashtable的key和value都是不能为null的 HashMap集合的key和value都是可以为null的 Hashtable方法都带有synchronized：线程安全的。 线程安全有其他的方案，这个Hashtable对线程的处理导致效率较低，使用较少了。 Hashtable和HashMap一样，底层都是哈希表数据结构 Hashtable的初始化容量是：11，默认加载因子：0.75f。 Hashtable的扩容：原容量*2+1 */ public class HashtableText01 { public static void main(String[] args) { Map map = new Hashtable(); //map.put(null,"122"); //map.put(12,null); } } -
Properties
package Collection; import java.util.Properties; /* 目前只需要掌握Properties属性类对象的相关方法即可 Properties是一个Map集合，继承Hashtable，Properties的key和value都是String类型 Properties被称为属性类对象。 properties是线程安全的。 */ public class PropertiesText01 { public static void main(String[] args) { //创建一个Properties对象 Properties pro = new Properties(); //需要掌握Properties的两个方法，一个存，一个取 pro.setProperty("url","jdbc:mysql://localhost:bjpowernode"); pro.setProperty("driver","com.mysql.jdbc.Driver"); pro.setProperty("username","root"); pro.setProperty("password","123"); //通过key获取value String url =pro.getProperty("url"); String driver =pro.getProperty("driver"); String username =pro.getProperty("username"); String password =pro.getProperty("password"); System.out.println(url); System.out.println(driver); System.out.println(username); System.out.println(password); } } -
TreeSet集合
可排序
package Collection; import javax.swing.event.TreeSelectionEvent; import java.util.TreeSet; /* 1、TreeSet集合底层实际上是一个TreeMap 2、TreeMap集合底层是一个二叉树 3、放到TreeSet集合中的元素，等同于放到TreeMap集合的key部分了。 4、TreeSet集合中的元素：无序不可重复，但是可以按照元素的大小顺序自动排序 称为：可排序集合 */ public class TreeSetText02 { public static void main(String[] args) { //创建一个TreeSet集合 TreeSet<String> ts = new TreeSet<>(); //添加String ts.add("zhangsan"); ts.add("lisi"); ts.add("wangwu"); ts.add("zhangsai"); ts.add("wangliu"); //遍历 for(String s :ts){ //按照字典顺序，升序 System.out.println(s); } TreeSet<Integer> ts2 = new TreeSet<>(); ts2.add(100); ts2.add(500); ts2.add(50); ts2.add(800); ts2.add(80); ts2.add(600); for(Integer i : ts2){ //升序 System.out.println(i); } } } /*数据库中有很多数据 userid name birth ------------------------------------------- 1 zs 1980-11-11 2 ls 1980-10-11 3 ww 1981-11-10 4 zl 1977-10-19 */ -
自定义类型如果存储到TreeSet集合中，如何可排序
自定义类型无法排序的原因：
package Collection; import java.util.TreeSet; /* 对自定义的类型来说，TreeSet可以排序吗？ 以下程序对于Person类型来说，无法排序。因为没有指定Person对象之间的比较规则 谁大谁小没有说明啊。 以下程序出现了这个异常： java.lang.ClassCastException: Collection.Person cannot be cast to java.lang.Comparable 出现这个异常的原因是： Person类没有实现java.lang.Comparable接口 */ public class TreeSetText03 { public static void main(String[] args) { Person p1 = new Person(32); Person p2 = new Person(20); Person p3 = new Person(30); Person p4 = new Person(25); System.out.println(p1); //创建TreeSet集合 TreeSet<Person> ts = new TreeSet<>(); ts.add(p1); ts.add(p2); ts.add(p3); ts.add(p4); for(Person p :ts){ System.out.println(p); } } } class Person{ int age; public Person(int age){ this.age = age; } //重写toString()方法 public String toString(){ return "Person[age="+age+"]"; } } -
第一种可排序的方式：实现java.lang.Comparable接口的可排序：
package Collection; import java.util.TreeSet; public class TreeSetText04 { public static void main(String[] args) { Customer c1 = new Customer(32); Customer c2 = new Customer(20); Customer c3 = new Customer(30); Customer c4 = new Customer(25); //创建TreeSet集合 TreeSet<Customer> customers = new TreeSet<>(); customers.add(c1); customers.add(c2); customers.add(c3); customers.add(c4); for(Customer c :customers){ System.out.println(c); } } } //放在TreeSet集合中的元素需要实现java.lang.Comparable接口 //并且实现compareTo方法，equals可以不写 class Customer implements Comparable<Customer>{ int age; public Customer(int age){ this.age = age; } //重写toString()方法 public String toString(){ return "Customer[age="+age+"]"; } /* 需要在这个方法里编写比较的逻辑，或者说比较的规则，按照什么进行比较！ k.compareTo(t.key) 拿着参数k和集合中的每一个k进行比较，返回值可能是>0、<0、=0 比较规则最终还是由程序员指定的:例如按照年龄升序，或者按照年龄降序 */ @Override public int compareTo(Customer c) {//c1.compareTo(c2); //this是c1 ，c是c2 c1和c2比较的时候，就是this和c比较 /* int age1 = this.age; int age2 = c.age; if(age1 == age2){ return 0; }else if(age1 > age2){ return 1; }else{ return -1; }*/ //升序 //return this.age - c.age; // <0、>0、=0 //降序 return c.age - this.age; } }排序规则如何写以及compareTo方法的解析
package Collection; import java.util.TreeSet; /* 先按照年龄升序，如果年龄一样的再按照姓名升序。 */ /* compareTo方法的返回值很重要： 返回0，表示相同，value会覆盖。 返回>0，会继续在右子树上找。【10 - 9 = 1，1>0 ，说明左边的数字比右边的这个大，所以在右子树上找】 返回<0，会继续在左子树上找。 */ public class TreeSetText05 { public static void main(String[] args) { TreeSet<Vip> vip = new TreeSet<>(); vip.add(new Vip("zhangsi",20)); vip.add(new Vip("zhangsan",20)); vip.add(new Vip("king",27)); vip.add(new Vip("ben",18)); for(Vip v :vip){ System.out.println(v); } } } class Vip implements Comparable<Vip> { String name; int age; public Vip(String name,int age){ this.name = name; this.age = age; } @Override public String toString() { return "Vip{" + "name='" + name + '\'' + ", age=" + age + '}'; } /* compareTo方法的返回值很重要： 返回0，表示相同，value会覆盖。 返回>0，会继续在右子树上找。【10 - 9 = 1，1>0 ，说明左边的数字比右边的这个大，所以在右子树上找】 返回<0，会继续在左子树上找。 */ @Override public int compareTo(Vip v) { //排序规则，按照什么进行比较？ if(this.age == v.age){ //年龄相同时按照名字排序。姓名是String类型，可以直接调用compareTo来完成比较。 return this.name.compareTo(v.name); }else{ //年龄不一样 return this.age - v.age; } } } -
自平衡二叉树数据结构
-
第二种可排序的方式：使用比较器。以及选择哪种方式使TreeSet集合可排序
package Collection; import java.util.Comparator; import java.util.TreeSet; /* TreeSet集合中元素可排序的第二种方式：使用比较器的方式 最终的结论： 放到TreeSet或者TreeMap集合key部分的元素想要做到排序，包括两种方式： 第一种：放在集合中的元素实现java.langComparable接口 第二种：在构造器TreeSet或者TreeMap集合的时候给它传一个比较器对象 Comparable 和Comparator怎么选择呢？ 当比较规则不会发生改变的时候，或者说当比较规则只有一个的时候，建议实现Comparable接口 如果比较规则有多个，并且需要多个比较规则之间频繁切换，建议使用Comparator接口 Comparator接口的而设计符合OCP原则。 */ public class TreeSetText06 { public static void main(String[] args) { //创建TreeSet集合的时候，需要使用这个比较器。 //TreeSet<WuGui> wuGuis = new TreeSet<>(); //这样不行，没有通过构造方法传递比较器 //使用构造方法传递构造器进去。 //TreeSet<WuGui> wuGuis = new TreeSet<>(new WuGuiComparator()); //大家可以使用匿名内部类的方式,（类没有名字，直接new接口） TreeSet<WuGui> wuGuis = new TreeSet<>(new Comparator<WuGui>() { @Override public int compare(WuGui o1, WuGui o2) { return o1.age -o2.age; } }); wuGuis.add(new WuGui(1000)); wuGuis.add(new WuGui(760)); wuGuis.add(new WuGui(666)); wuGuis.add(new WuGui(1111)); for(WuGui wuGui : wuGuis){ System.out.println(wuGui); } } } //乌龟 class WuGui{ int age; public WuGui(int age){ this.age = age; } @Override public String toString() { return "小乌龟{" + "age=" + age + '}'; } } //单独在这里编写一个比较器 //比较器实现java.util.Comparator接口（comparable 是java.lang包下的。Comparator是java.util包下的） /*class WuGuiComparator implements Comparator<WuGui> { @Override public int compare(WuGui o1, WuGui o2) { //指定年龄规则 //按照年龄排序 return o1.age - o2.age; } }*/
java.util.Collections集合工具类
package Collection;
import java.util.*;
/*
java.util.Collection 集合接口
java.util.Collections 集合工具类，方便集合的操作
*/
public class CollectionsText {
public static void main(String[] args) {
//ArrayList集合不是线程安全的
List<String> list = new ArrayList<>();
//变成线程安全的
Collections.synchronizedList(list);
//添加元素
list.add("abf");
list.add("abx");
list.add("abc");
list.add("abe");
//排序
Collections.sort(list);
//遍历
for(String s :list){
System.out.println(s);
}
List<WuGui2> wuGui2s = new ArrayList<>();
wuGui2s.add(new WuGui2(120));
wuGui2s.add(new WuGui2(90));
//注意：对List集合中元素排序，需要保证List集合中的元素实现了：Comparable接口
Collections.sort(wuGui2s);
for(WuGui2 wg : wuGui2s){
System.out.println(wg);
}
//对Set集合怎么排序呢？
Set<String> set = new HashSet<>();
set.add("king");
set.add("kingaoft");
set.add("king2");
set.add("king900");
//将Set集合转换成List集合
List<String> myList = new ArrayList<>(set);
Collections.sort(myList);
for(String l : myList){
System.out.println(l);
}
//这种方式也可以排序
//Collection.sort(list集合,比较器对象)
}
}
class WuGui2 implements Comparable<WuGui2>{
int age;
public WuGui2(int age){
this.age = age;
}
@Override
public String toString() {
return "小乌龟{" +
"age=" + age +
'}';
}
@Override
public int compareTo(WuGui2 w) {
return this.age - w.age;
}
}
复习review
集合中最最要掌握的
-
每个集合对象的创建（new）
-
向集合中添加元素
-
从集合中取出某个元素
-
遍历集合
-
主要的集合类：
ArrayList LinkedList HashSet(HashMap的key，存储在HashMap集合key的元素，需要同时重写hashCode+equals) TreeSet HashMap Properties TreeMap
-
ArrayList/LinkedList
package review; import java.util.ArrayList; import java.util.Iterator; import java.util.LinkedList; /* - 每个集合对象的创建（new） - 向集合中添加元素 - 从集合中取出某个元素 - 遍历集合 */ public class ArrayListText { public static void main(String[] args) { //创建集合对象 //ArrayList<String> list = new ArrayList<>(); LinkedList<String> list = new LinkedList<>(); //添加元素 list.add("zhangsan"); list.add("lisi"); list.add("wangwu"); //从集合中取出某个元素 //list集合有下标 String firstElet = list.get(0); System.out.println(firstElet); //遍历（下标方式） for(int i = 0; i < list.size();i++){ System.out.println(list.get(i)); } //迭代器方式，这个是通用的，所有Collection Iterator it = list.iterator(); while(it.hasNext()){ System.out.println(it.next()); } System.out.println("==================================="); //while循环修改为for循环 for(Iterator it2 = list.iterator();it2.hasNext();){ System.out.println(it2.next()); } System.out.println("==================================="); //forecah for(String s :list){ System.out.println(s); } } } -
HashSet
package review; import java.util.*; /* - 每个集合对象的创建（new） - 向集合中添加元素 - 从集合中取出某个元素 - 遍历集合 - 测试HashSet集合的特点：无序不可重复 */ public class HashSetText { public static void main(String[] args) { //创建集合对象 HashSet<String> set = new HashSet<>(); //添加元素 set.add("abc"); set.add("king"); set.add("xyz"); //Set集合中的元素没有下标，所以不能通过下标取元素 //遍历（迭代器） Iterator it = set.iterator(); while(it.hasNext()){ System.out.println(it.next()); } set.add("king"); set.add("king"); set.add("king"); System.out.println(set.size()); //3 //后面的三个king都没有加进去 set.add("1"); set.add("10"); set.add("8"); //遍历集合（foreach） for (String s :set){ System.out.println(s); } /* 1 abc king xyz 8 10 */ //创建Set集合，存储Student数据 Set<Student> students = new HashSet<>(); Student s1 = new Student(11,"zhangsan"); Student s2 = new Student(22,"lisi"); Student s3 = new Student(11,"zhangsan"); students.add(s1); students.add(s2); students.add(s3); System.out.println(students.size());//2 //遍历 for(Student stu : students){ System.out.println(stu); } } } class Student{ int no; String name; public Student(){ } public Student(int no ,String name){ this.no = no ; this.name = name; } @Override public String toString() { return "Student{" + "no=" + no + ", name='" + name + '\'' + '}'; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Student student = (Student) o; return no == student.no && Objects.equals(name, student.name); } @Override public int hashCode() { return Objects.hash(no, name); } } -
TreeSet
package review; import java.util.Comparator; import java.util.Iterator; import java.util.TreeSet; /* - 每个集合对象的创建（new） - 向集合中添加元素 - 从集合中取出某个元素 - 遍历集合 - 测试TreeSet集合中的元素是可排序的 - 测试TreeSet集合中存储的类型是自定义的 - 测试Comparable接口的方式 - 测试Comparator接口的方式(最好测试匿名内部类的方式) */ public class TreeSetText { public static void main(String[] args) { //集合的创建(可以测试以下TreeSet集合存储String、Integer的，这些都是SUN写好的) //TreeSet<Integer> ts = new TreeSet<>(); //编写比较器可以改变规则 TreeSet<Integer> ts = new TreeSet<>(new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { return o2-o1; //自动拆箱 } }); //添加元素 ts.add(1); ts.add(10); ts.add(10); ts.add(10); ts.add(0); ts.add(100); //遍历（迭代器方式） Iterator<Integer> it =ts.iterator(); while(it.hasNext()){ System.out.println(it.next()); } //foreach遍历 for(Integer i : ts){ System.out.println(i); } //TreeSet集合中存储自定义类型 TreeSet<A> atree = new TreeSet<>(); atree.add(new A(100)); atree.add(new A(500)); atree.add(new A(300)); atree.add(new A(400)); atree.add(new A(80)); //遍历 for(A a :atree){ System.out.println(a); } //比较器 //TreeSet<B> btree = new TreeSet<>(new BComparator()); //匿名内部类的方式 TreeSet<B> btree = new TreeSet<>(new Comparator<B>() { @Override public int compare(B o1, B o2) { return o2.i-o1.i; } }); btree.add(new B(100)); btree.add(new B(10)); btree.add(new B(7400)); btree.add(new B(150)); btree.add(new B(840)); btree.add(new B(920)); for(B b : btree){ System.out.println(b); } } } class A implements Comparable<A>{ int i ; public A(int i){ this.i = i ; } @Override public String toString() { return "A{" + "i=" + i + '}'; } public int compareTo(A a) { //升序 //return this.i -a.i; //降序 return a.i-this.i; } } class B{ int i ; public B(int i){ this.i = i; } @Override public String toString() { return "B{" + "i=" + i + '}'; } } //B的比较器 class BComparator implements Comparator<B>{ @Override public int compare(B o1, B o2) { return o1.i-o2.i; } } -
HashMap
package review; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; /* - 每个集合对象的创建（new） - 向集合中添加元素 - 从集合中取出某个元素 - 遍历集合 */ public class HashMapText { public static void main(String[] args) { //创建Map集合 Map<Integer,String> map = new HashMap<>(); //添加元素 map.put(1,"zhangsan"); map.put(4,"lisi"); map.put(5,"wangwu"); map.put(7,"zhaoliu"); map.put(7,"zl"); //key重复，value会自动覆盖 //获取元素个数 System.out.println(map.size()); //4f //取key为7的元素 System.out.println(map.get(7)); //zl //遍历Map集合很重要，几种方式都要掌握 //第一种方式：先获取所有的key，遍历key的时候，通过key获取value Set<Integer> keys = map.keySet(); for(Integer key : keys){ System.out.println(key + "=" + map.get(key)); } //第二种方式：是将Map集合转换成Set集合，Set集合中每一个元素是Node，这个Node节点中有key和value Set<Map.Entry<Integer,String>> nodes = map.entrySet(); for(Map.Entry<Integer,String> me : nodes){ System.out.println(me.getKey()+"="+me.getValue()); } } } -
Properties
package review; import java.util.Properties; public class PropertiesText { public static void main(String[] args) { //创建对象 Properties pro = new Properties(); //存 pro.setProperty("username","zhang"); pro.setProperty("password","13"); //取 String name = pro.getProperty("username"); String pass = pro.getProperty("password"); System.out.println(name +pass); } }
扫一扫
891
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
