为什么原网站建设公司不愿意透露域名管理权限给客户,网页设计用的软件,wordpress头像不同步,陕西网站建设价格1. Collection
1.1 Java类中集合的关系图 1.2 集合类概述
在程序中可以通过数组来保存多个对象#xff0c;但在某些情况下开发人员无法预先确定需要保存对象的个数#xff0c;此时数组将不再适用#xff0c;因为数组的长度不可变。例如#xff0c;要保存一个学校的学生信…
1. Collection
1.1 Java类中集合的关系图 1.2 集合类概述
在程序中可以通过数组来保存多个对象但在某些情况下开发人员无法预先确定需要保存对象的个数此时数组将不再适用因为数组的长度不可变。例如要保存一个学校的学生信息由于不停有新生来报道同时也有学生毕业离开学校这时学生的数目就很难确定。为了在程序中可以保存这些数目不确定的对象JDK中提供了一系列特殊的类这些类可以存储任意类型的对象并且长度可变在Java中这些类被统称为集合。集合类都位于java.util包中在使用时一定要注意导包的问题否则会出现异常。
1.2.1 为什么出现集合类
面向对象语言对事物的体现都是以对象的形式所以为了方便对多个对象的操作Java就提供了集合类。
1.2.2 数组和集合类有何不同 1.2.3 集合类的特点
集合只用于存储对象集合长度是可变的集合可以存储不同类型的对象。
1.3 Collection接口概述
Collection单列集合类的根接口用于存储一系列符合某种规则的元素它有两个重要的子接口分别是List和Set。其中List的特点是元素有序、元素可重复。Set的特点是元素无序而且不可重复。List接口的主要实现类有ArrayList和LinkedListSet接口的主要实现类有HashSet和TreeSet。
Collection 层次结构中的根接口。Collection 表示一组对象这些对象也称为 collection 的元素。一些 collection 允许有重复的元素而另一些则不允许。一些 collection 是有序的而另一些则是无序的。 1.4 Collection接口成员方法
集合层次结构中的根接口。Collection表示一组对象这些对象也称为Collection的元素。一些Collection允许有重复的元素而另一些则不允许。一些Collection是有序的而另一些则是无序的。
添加功能
方法声明功能描述add()添加元素addAll()添加一个集合的元素
删除功能
方法声明功能描述remove()删除元素removeAll()删除一个集合的元素clear()清空集合
判断功能
方法声明功能描述contains()判断集合是否包含指定的元素containsAll()判断一个集合是否包含一个集合的元素isEmpty()判断集合是否为空
获取功能
方法声明功能描述size()获取集合的长度retainAll()取两个集合的交集
其他功能
方法声明功能描述toArray()把集合转成数组可以实现集合的遍历iterator()迭代器集合的专用遍历方式 2. List
有序的 collection也称为序列/线性表。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引在列表中的位置访问元素并搜索列表中的元素。与 set 不同列表通常允许重复的元素。
List接口是Collection接口的一个子接口List集合的特性是有序可重复元素有索引List接口有三个实现类
ArrayList底层数据结构是数组查询快增删慢非线程安全效率高数据增长为原来的50%Vector底层数据结构是数组查询快增删慢线程安全效率低数据增长为原来的一倍LinkedList底层数据结构是链表查询慢增删快非线程安全效率高
2.1 Vector
底层数据结构是数组查询快增删慢线程安全效率低。
Vector类特有功能
public void addElement(E obj)添加元素public E elementAt(int index)根据索引获取元素public Enumeration elements()获取所有的元素
2.2 ArrayList
ArrayList 类是一个可以动态修改的数组与普通数组的区别就是它是没有固定大小的限制我们可以添加或删除元素。
ArrayList 继承了 AbstractList 并实现了 List 接口。
底层数据结构是数组查询快增删慢线程不安全效率高。 Java ArrayList 常用方法列表如下
方法声明功能描述add()将元素插入到指定位置的 arraylist 中addAll()添加集合中的所有元素到 arraylist 中clear()删除 arraylist 中的所有元素clone()复制一份 arraylistcontains()判断元素是否在 arraylistget()通过索引值获取 arraylist 中的元素indexOf()返回 arraylist 中元素的索引值removeAll()删除存在于指定集合中的 arraylist 里的所有元素remove()删除 arraylist 里的单个元素size()返回 arraylist 里元素数量isEmpty()判断 arraylist 是否为空subList()截取部分 arraylist 的元素set()替换 arraylist 中指定索引的元素sort()对 arraylist 元素进行排序toArray()将 arraylist 转换为数组toString()将 arraylist 转换为字符串ensureCapacity()设置指定容量大小的 arraylistlastIndexOf()返回指定元素在 arraylist 中最后一次出现的位置retainAll()保留 arraylist 中在指定集合中也存在的那些元素containsAll()查看 arraylist 是否包含指定集合中的所有元素trimToSize()将 arraylist 中的容量调整为数组中的元素个数removeRange()删除 arraylist 中指定索引之间存在的元素replaceAll()将给定的操作内容替换掉数组中每一个元素removeIf()删除所有满足特定条件的 arraylist 元素forEach()遍历 arraylist 中每一个元素并执行特定操作
2.3 LinkedList
链表Linked list是一种常见的基础数据结构是一种线性表但是并不会按线性的顺序存储数据而是在每一个节点里存到下一个节点的地址。
链表可分为单向链表和双向链表。
一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的链接。 一个双向链表有三个整数值: 数值、向后的节点链接、向前的节点链接。 Java LinkedList链表 类似于 ArrayList是一种常用的数据容器。
与 ArrayList 相比LinkedList 的增加和删除的操作效率更高而查找和修改的操作效率较低。
以下情况使用 ArrayList :
频繁访问列表中的某一个元素。只需要在列表末尾进行添加和删除元素操作。
以下情况使用 LinkedList :
你需要通过循环迭代来访问列表中的某些元素。需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。
LinkedList 继承了 AbstractSequentialList 类。
LinkedList 实现了 Queue 接口可作为队列使用。
LinkedList 实现了 List 接口可进行列表的相关操作。
LinkedList 实现了 Deque 接口可作为队列使用。
LinkedList 实现了 Cloneable 接口可实现克隆。
LinkedList 实现了 java.io.Serializable 接口即可支持序列化能通过序列化去传输。 常用方法
方法声明功能描述public boolean add(E e)链表末尾添加元素返回是否成功成功为 true失败为 false。public void add(int index, E element)向指定位置插入元素。public boolean addAll(Collection c)将一个集合的所有元素添加到链表后面返回是否成功成功为 true失败为 false。public boolean addAll(int index, Collection c)将一个集合的所有元素添加到链表的指定位置后面返回是否成功成功为 true失败为 false。public void addFirst(E e)元素添加到头部。public void addLast(E e)元素添加到尾部。public boolean offer(E e)向链表末尾添加元素返回是否成功成功为 true失败为 false。public boolean offerFirst(E e)头部插入元素返回是否成功成功为 true失败为 false。public boolean offerLast(E e)尾部插入元素返回是否成功成功为 true失败为 false。public void clear()清空链表。public E removeFirst()删除并返回第一个元素。public E removeLast()删除并返回最后一个元素。public boolean remove(Object o)删除某一元素返回是否成功成功为 true失败为 false。public E remove(int index)删除指定位置的元素。public E poll()删除并返回第一个元素。public E remove()删除并返回第一个元素。public boolean contains(Object o)判断是否含有某一元素。public E get(int index)返回指定位置的元素。public E getFirst()返回第一个元素。public E getLast()返回最后一个元素。public int indexOf(Object o)查找指定元素从前往后第一次出现的索引。public int lastIndexOf(Object o)查找指定元素最后一次出现的索引。public E peek()返回第一个元素。public E element()返回第一个元素。public E peekFirst()返回头部元素。public E peekLast()返回尾部元素。public E set(int index, E element)设置指定位置的元素。public Object clone()克隆该列表。public Iterator descendingIterator()返回倒序迭代器。public int size()返回链表元素个数。public ListIterator listIterator(int index)返回从指定位置开始到末尾的迭代器。public Object[] toArray()返回一个由链表元素组成的数组。public T[] toArray(T[] a)返回一个由链表元素转换类型而成的数组。
代码示例使用LinkedList来模拟一个栈数据结构
package cn.itcast;import java.util.LinkedList;/**使用LinkedList模拟栈数据结构的集合并测试*1、栈的特点先进后出*2、 LinkedList的特有添加功能addFirst()*/
class MyStack {private LinkedList link;public MyStack() {link new LinkedList();}public void add(Object obj) {// 将指定元素插入此列表的开头link.addFirst(obj);}public Object get() {// 移除并返回此列表的第一个元素。// return link.getFirst();return link.removeFirst();}public boolean isEmpty() {return link.isEmpty();}
}/** MyStack的测试*/
public class MyStackDemo {public static void main(String[] args) {// 创建集合对象MyStack ms new MyStack();// 添加元素ms.add(hello);ms.add(world);ms.add(java);ms.add(android);ms.add(javase);while (!ms.isEmpty()) {System.out.println(ms.get());}}
}3. Set
一个不包含重复元素的 collection无序。
哈希表确定元素是否相同
1、 判断的是两个元素的哈希值是否相同。 如果相同再判断两个对象的内容是否相同。
2、 判断哈希值相同其实判断的是对象的HashCode方法。判断内容相同用的是equals方法。
3.1 HashSet类概述 不保证 set 的迭代顺序特别是它不保证该顺序恒久不变。HashSet如何保证元素唯一性底层数据结构是哈希表(元素是链表的数组)哈希表依赖于哈希值存储添加功能底层依赖两个方法int hashCode()、boolean equals(Object obj)
HashSet集合之所以能确保不出现重复的元素是因为它在存入元素时做了很多工作。当调用HashSet集合的add()方法存入元素时首先调用当前存入对象的hashCode()方法获得对象的哈希值然后根据对象的哈希值计算出一个存储位置。如果该位置上没有元素则直接将元素存入如果该位置上有元素存在则会调用equals()方法让当前存入的元素依次和该位置上的元素进行比较如果返回的结果为false就将该元素存入集合返回的结果为true则说明有重复元素就将该元素舍弃。
package cn.itcast;import java.util.HashSet;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;}Overridepublic 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;}Overridepublic 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;}}/** HashSet集合存储自定义对象并遍历。如果对象的成员变量值相同即为同一个对象* * 注意了 你使用的是HashSet集合这个集合的底层是哈希表结构。 而哈希表结构底层依赖:hashCode()和equals()方法。* 如果你认为对象的成员变量值相同即为同一个对象的话你就应该重写这两个方法。 如何重写呢?不同担心自动生成即可。*/
public class DogDemo {public static void main(String[] args) {// 创建集合对象HashSetDog hs new HashSetDog();// 创建狗对象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());}}
}3.2 LinkedHashSet类概述
元素有序唯一由链表保证元素有序由哈希表保证元素唯一。
3.3 TreeSet类概述
使用元素的自然顺序对元素进行排序或者根据创建 set 时提供的 Comparator 进行排序具体取决于使用的构造方法。 TreeSet是如何保证元素的排序和唯一性 底层数据结构是红黑树(红黑树是一种自平衡的二叉树) TreeSet判断元素唯一性的方式 就是根据比较方法的返回结果是否是0是0就是相同元素不存。 TreeSet对元素进行排序的方式一 让元素自身具备比较功能元素就需要实现Comparable接口覆盖compareTo方法。 如果不要按照对象中具备的自然顺序进行排序。如果对象中不具备自然顺序。怎么办 可以使用TreeSet集合第二种排序方式 让集合自身具备比较功能定义一个类实现Comparator接口覆盖compare方法。将该类对象作为参数传递给TreeSet集合的构造函数。
package cn.itcast;import java.util.Comparator;
import java.util.TreeSet;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;}
}class MyComparator implements ComparatorStudent {public int compare(Student s1, Student s2) {// int num this.name.length() - s.name.length();// this -- s1// s -- 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;}}/** 需求请按照姓名的长度排序* * TreeSet集合保证元素排序和唯一性的原理 唯一性是根据比较的返回是否是0来决定。 排序 A:自然排序(元素具备比较性)* 让元素所属的类实现自然排序接口 Comparable B:比较器排序(集合具备比较性) 让集合的构造方法接收一个比较器接口的子类对象 Comparator*/
public class TreeSetDemo {public static void main(String[] args) {// 创建集合对象// TreeSetStudent ts new TreeSetStudent(); //自然排序// public TreeSet(Comparator comparator) //比较器排序// TreeSetStudent ts new TreeSetStudent(new MyComparator());// 如果一个方法的参数是接口那么真正要的是接口的实现类的对象// 而匿名内部类就可以实现这个东西TreeSetStudent ts new TreeSetStudent(new ComparatorStudent() {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());}}
}4. Queue
4.1 栈
栈stack是一种用于存储数据的简单数据结构。栈一个有序线性表只能在表的一端PS栈顶执行插人和删除操作。最后插人的元素将被第一个删除。所以栈也称为后进先出Last In First Out,LIFO或先进后出First In Last Out,FILO线性表。
栈的实现可以有数组实现的顺序栈和链表结构的链式栈
java预定义的栈实现
public class StackE extends VectorE 实现方式为自定义实现的可变长数组线程安全
Java集合框架中的Stack 继承自Vector
由于 Vector 有 4 个构造函数加上 Stack 本身的一种也就是说有 5 中创建 Stack 的方法跟 Vector 一样它是可以由数组实现的栈。
栈的集中主要操作
E push(E item) 把项压入堆栈顶部synchronized E pop() 移除堆栈顶部的对象并作为此函数的值返回该对象synchronized E peek() 查看堆栈顶部的对象但不从堆栈中移除它boolean empty() 测试堆栈是否为空synchronized int search(Object o) 返回对象在堆栈中的位置以 1 为基数
4.2 队列 Queue接口 PriorityQueue 优先队列ConcurrentLinkedQueue 支持并发访问的基于链表的队列 插入 add()offer() 删除 remove()poll() 检查 element()peek()
4.3 阻塞队列
阻塞队列可以阻塞当阻塞队列当队列里面没有值时会阻塞直到有值输入。输入也一样当队列满的时候会阻塞直到队列有空间。
BlockingQueue
ArrayBlockingQueue 顺序阻塞队列LinkedBlockingQueue 链式阻塞队列PriorityBlockingQueue 优先阻塞队列SynchronousQueue 同步阻塞队列DelayQueueBlockingDeque 双端阻塞队列 LinkedBlockingDeque 基于链表的双端阻塞队列
阻塞队列提供了另外4个非常有用的方法
put(E e)用来向队尾存入元素如果队列满则等待take()用来从队首取元素如果队列为空则等待offer(E e,long timeout, TimeUnit unit)用来向队尾存入元素如果队列满则等待一定的时间当时间期限达到时如果还没有插入成功则返回false否则返回truepoll(long timeout, TimeUnit unit)用来从队首取元素。如果队列空则会等待 timeout 时间后进行一次重试如果取不到则返回null否则返回取得的元素
4.4 Deque 双端队列
可以当成队列和栈使用
ArrayDequeLinkedBlockingDequeLinkedList
方法说明功能说明addFirst()队首添加元素addLast()队尾添加元素offerFirst()队首添加元素offerLast()队尾添加元素removeFirst()删除队首元素removeLast()删除队尾元素pollFirst()返回并删除队首元素pollLast()返回并删除队尾元素getFirst()获取队首元素如果队列为空则抛异常getLast()获取队尾元素如果队列为空则抛异常peekFirst()获取队首元素如果队列为空则返回nullpeekLast()获取队尾元素如果队列为空则返回null
5. Map
Map双列集合类的根接口用于存储具有键(Key)、值(Value)映射关系的元素每个元素都包含一对键值在使用Map集合时可以通过指定的Key找到对应的Value例如根据一个学生的学号就可以找到对应的学生。Map接口的主要实现类有HashMap和TreeMap。
将键映射到值的对象一个映射不能包含重复的键每个键最多只能映射到一个值。其实Map集合中存储的就是键值对。map集合中必须保证键的唯一性。
Map接口和Collection接口的不同
Map是双列的,Collection是单列的Map的键唯一,Collection的子体系Set是唯一的Map集合的数据结构值针对键有效跟值无关Collection集合的数据结构是针对元素有效
Map常用的子类
Hashtable内部结构是哈希表是同步的。不允许null作为键null作为值。Properties用来存储键值对型的配置文件的信息可以和IO技术相结合。HashMap内部结构式哈希表不是同步的。允许null作为键null作为值。TreeMap内部结构式二叉树不是同步的。可以对Map结合中的键进行排序。HashSet实现Set接口由哈希表实际上是一个HashMap实例支持。
5.1 Map接口常用方法
方法声明功能描述put(K key, V value)有添加和替换功能putAll(Map m)添加一个Map的元素clear()清空集合remove(Object key)根据键删除一个元素containsKey()判断集合是否包含指定的键containsValue()判断集合是否包含指定的值isEmpty()判断集合是否为空get(Object key)根据键获取值keySet()获取所有的键values()获取所有的值entrySet()获取所有的Entrysize()获取集合元素的个数
5.2 HashMap 键是哈希表结构可以保证键的唯一性
5.3 LinkedHashMap
Map 接口的哈希表和链接列表实现具有可预知的迭代顺序。
5.4 TreeMap
键是红黑树结构可以保证键的排序和唯一性自然排序比较器排序。
5.5 Map集合遍历
方式1根据键找值。获取所有键的集合遍历键的集合获取到每一个键根据键找值。
package cn.itcast;import java.util.HashMap;
import java.util.Map;
import java.util.Set;/** Map集合的遍历。* Map -- 夫妻对* 思路* A:把所有的丈夫给集中起来。* B:遍历丈夫的集合获取得到每一个丈夫。* C:让丈夫去找自己的妻子。* * 转换* A:获取所有的键* B:遍历键的集合获取得到每一个键* C:根据键去找值*/
public class MapDemo {public static void main(String[] args) {// 创建集合对象MapString, String map new HashMapString, String();// 创建元素并添加到集合map.put(杨过, 小龙女);map.put(郭靖, 黄蓉);map.put(杨康, 穆念慈);map.put(陈玄风, 梅超风);// 遍历// 获取所有的键SetString set map.keySet();// 遍历键的集合获取得到每一个键for (String key : set) {// 根据键去找值String value map.get(key);System.out.println(key --- value);}}
}方式2根据键值对对象找键和值。
获取所有键值对对象的集合遍历键值对对象的集合获取到每一个键值对对象根据键值对对象找键和值
package cn.itcast;import java.util.HashMap;
import java.util.Map;
import java.util.Set;/** Map集合的遍历。* Map -- 夫妻对* * 思路* A:获取所有结婚证的集合* B:遍历结婚证的集合得到每一个结婚证* C:根据结婚证获取丈夫和妻子* * 转换* A:获取所有键值对对象的集合* B:遍历键值对对象的集合得到每一个键值对对象* C:根据键值对对象获取键和值* * 这里面最麻烦的就是键值对对象如何表示呢?* 看看我们开始的一个方法* SetMap.EntryK,V entrySet()返回的是键值对对象的集合*/
public class MapDemo {public static void main(String[] args) {// 创建集合对象MapString, String map new HashMapString, String();// 创建元素并添加到集合map.put(杨过, 小龙女);map.put(郭靖, 黄蓉);map.put(杨康, 穆念慈);map.put(陈玄风, 梅超风);// 获取所有键值对对象的集合SetMap.EntryString, String set map.entrySet();// 遍历键值对对象的集合得到每一个键值对对象for (Map.EntryString, String me : set) {// 根据键值对对象获取键和值String key me.getKey();String value me.getValue();System.out.println(key --- value);}}
}5.6 Map集合的应用及扩展
package cn.itcast;import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;/** 需求 aababcabcdabcde,获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)* * 分析* A:定义一个字符串(可以改进为键盘录入)* B:定义一个TreeMap集合* 键:Character* 值Integer* C:把字符串转换为字符数组* D:遍历字符数组得到每一个字符* E:拿刚才得到的字符作为键到集合中去找值看返回值* 是null:说明该键不存在就把该字符作为键1作为值存储* 不是null:说明该键存在就把值加1然后重写存储该键和值* F:定义字符串缓冲区变量* G:遍历集合得到键和值进行按照要求拼接* H:把字符串缓冲区转换为字符串输出* * 录入linqingxia* 结果result:a(1)g(1)i(3)l(1)n(2)q(1)x(1)*/
public class TreeMapDemo {public static void main(String[] args) {// 定义一个字符串(可以改进为键盘录入)Scanner sc new Scanner(System.in);System.out.println(请输入一个字符串);String line sc.nextLine();// 定义一个TreeMap集合TreeMapCharacter, Integer tm new TreeMapCharacter, Integer();// 把字符串转换为字符数组char[] chs line.toCharArray();// 遍历字符数组得到每一个字符for (char ch : chs) {// 拿刚才得到的字符作为键到集合中去找值看返回值Integer i tm.get(ch);// 是null:说明该键不存在就把该字符作为键1作为值存储if (i null) {tm.put(ch, 1);} else {// 不是null:说明该键存在就把值加1然后重写存储该键和值i;tm.put(ch, i);}}// 定义字符串缓冲区变量StringBuilder sb new StringBuilder();// 遍历集合得到键和值进行按照要求拼接SetCharacter set tm.keySet();for (Character key : set) {Integer value tm.get(key);sb.append(key).append(().append(value).append());}// 把字符串缓冲区转换为字符串输出String result sb.toString();System.out.println(result: result);}
}示例2在很多项目中应用比较多的是一对多的映射关系这就可以通过嵌套的形式将多个映射定义到一个大的集合中并将大的集合分级处理形成一个体系。
package cn.itcast;import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;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;}}
/** 黑马程序员* bj 北京校区* jc 基础班* 林青霞 27* 风清扬 30* jy 就业班 * 赵雅芝 28* 武鑫 29* sh 上海校区* jc 基础班* 郭美美 20* 犀利哥 22* jy 就业班 * 罗玉凤 21* 马征 23* gz 广州校区* jc 基础班* 王力宏 30* 李静磊 32* jy 就业班 * 郎朗 31* 柳岩 33* xa 西安校区* jc 基础班* 范冰冰 27* 刘意 30* jy 就业班 * 李冰冰 28* 张志豪 29*/
public class HashMapDemo {public static void main(String[] args) {// 创建大集合HashMapString, HashMapString, ArrayListStudent czbkMap new HashMapString, HashMapString, ArrayListStudent();// 北京校区数据HashMapString, ArrayListStudent bjCzbkMap new HashMapString, ArrayListStudent();ArrayListStudent array1 new ArrayListStudent();Student s1 new Student(林青霞, 27);Student s2 new Student(风清扬, 30);array1.add(s1);array1.add(s2);ArrayListStudent array2 new ArrayListStudent();Student s3 new Student(赵雅芝, 28);Student s4 new Student(武鑫, 29);array2.add(s3);array2.add(s4);bjCzbkMap.put(基础班, array1);bjCzbkMap.put(就业班, array2);czbkMap.put(北京校区, bjCzbkMap);// 西安校区数据HashMapString, ArrayListStudent xaCzbkMap new HashMapString, ArrayListStudent();ArrayListStudent array3 new ArrayListStudent();Student s5 new Student(范冰冰, 27);Student s6 new Student(刘意, 30);array3.add(s5);array3.add(s6);ArrayListStudent array4 new ArrayListStudent();Student s7 new Student(李冰冰, 28);Student s8 new Student(张志豪, 29);array4.add(s7);array4.add(s8);xaCzbkMap.put(基础班, array3);xaCzbkMap.put(就业班, array4);czbkMap.put(西安校区, xaCzbkMap);// 遍历集合SetString czbkMapSet czbkMap.keySet();for (String czbkMapKey : czbkMapSet) {System.out.println(czbkMapKey);HashMapString, ArrayListStudent czbkMapValue czbkMap.get(czbkMapKey);SetString czbkMapValueSet czbkMapValue.keySet();for (String czbkMapValueKey : czbkMapValueSet) {System.out.println(\t czbkMapValueKey);ArrayListStudent czbkMapValueValue czbkMapValue.get(czbkMapValueKey);for (Student s : czbkMapValueValue) {System.out.println(\t\t s.getName() --- s.getAge());}}}}
}6. 集合操作
6.1 Collections工具类
Collections类概述
针对集合操作 的工具类里面的方法都是静态的可以对集合进行排序、二分查找、反转、混排等。
Collection和Collections的区别
Collection:是单列集合的顶层接口有子接口List和Set。Collections:是针对集合操作的工具类有对集合进行排序和二分查找等方法
Collections常用方法
public static T void sort(ListT list)
使用sort方法可以根据元素的自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable 接口。此列表内的所有元素都必须是使用指定比较器可相互比较的
public static T int binarySearch(List? list,T key)
使用二分搜索法搜索指定列表以获得指定对象。
public static T T max(Collection? coll)
根据元素的自然顺序返回给定 collection 的最大元素。
public static void reverse(List? list)
反转指定列表中元素的顺序。
public static void shuffle(List? list)
混排算法所做的正好与 sort 相反: 它打乱在一个 List 中可能有的任何排列的踪迹。也就是说基于随机源的输入重排该 List, 这样的排列具有相同的可能性假设随机源是公正的。这个算法在实现一个碰运气的游戏中是非常有用的。例如它可被用来混排代表一副牌的 Card 对象的一个 List 。另外在生成测试案例时它也是十分有用的。
fill(List? super T list, T obj)
使用指定元素替换指定列表中的所有元素。
copy(List? super T dest, List? extends T src)
将所有元素从一个列表复制到另一个列表。用两个参数一个目标 List 和一个源 List, 将源的元素拷贝到目标并覆盖它的内容。目标 List 至少与源一样长。如果它更长则在目标 List 中的剩余元素不受影响。
集合线程安全化
ListT synchronizedList(ListT list);//返回支持的同步线程安全的List集合
MapK,V synchronizedMap(MapK,V m); //返回支持的同步线程安全的Map集合
package cn.itcast_01;import java.util.Collections;
import java.util.List;
import java.util.ArrayList;/** Collections:是针对集合进行操作的工具类都是静态方法。* * 面试题* Collection和Collections的区别?* Collection:是单列集合的顶层接口有子接口List和Set。* Collections:是针对集合操作的工具类有对集合进行排序和二分查找的方法* * 要知道的方法* public static T void sort(ListT list)排序 默认情况下是自然顺序。* public static T int binarySearch(List? list,T key):二分查找* public static T T max(Collection? coll):最大值* public static void reverse(List? list):反转* public static void shuffle(List? list):随机置换*/
public class CollectionsDemo {public static void main(String[] args) {// 创建集合对象ListInteger list new ArrayListInteger();// 添加元素list.add(30);list.add(20);list.add(50);list.add(10);list.add(40);System.out.println(list: list);// public static T void sort(ListT list)排序 默认情况下是自然顺序。// Collections.sort(list);// System.out.println(list: list);// [10, 20, 30, 40, 50]// public static T int binarySearch(List? list,T key):二分查找// System.out// .println(binarySearch: Collections.binarySearch(list, 30));// System.out.println(binarySearch:// Collections.binarySearch(list, 300));// public static T T max(Collection? coll):最大值// System.out.println(max:Collections.max(list));// public static void reverse(List? list):反转// Collections.reverse(list);// System.out.println(list: list);//public static void shuffle(List? list):随机置换Collections.shuffle(list);System.out.println(list: list);}
}6.2 Arrays工具类
概述
此类包含用来操作数组比如排序和搜索的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。
常用方法
Array是Java特有的数组。在你知道所要处理数据元素个数的情况下非常好用。java.util.Arrays 包含了许多处理数据的实用方法
方法声明功能描述Arrays.asList()可以从 Array 转换成 List。可以作为其他集合类型构造器的参数Arrays.binarySearch()在一个已排序的或者其中一段中快速查找Arrays.copyOf()如果你想扩大数组容量又不想改变它的内容的时候可以使用这个方法Arrays.copyOfRange()可以复制整个数组或其中的一部分Arrays.deepEquals()Arrays.deepHashCode()Arrays.equals/hashCode的高级版本支持子数组的操作Arrays.equals()如果你想要比较两个数组是否相等应该调用这个方法而不是数组对象中的 equals方法数组对象中没有重写equals()方法所以这个方法之比较引用而不比较内容。这个方法集合了Java 5的自动装箱和无参变量的特性来实现将一个变量快速地传给 equals()方法——所以这个方法在比较了对象的类型之后是直接传值进去比较的Arrays.fill()用一个给定的值填充整个数组或其中的一部分Arrays.hashCode()用来根据数组的内容计算其哈希值数组对象的hashCode()不可用。这个方法集合了Java 5的自动装箱和无参变量的特性来实现将一个变量快速地传给 Arrays.hashcode方法——只是传值进去不是对象Arrays.sort()对整个数组或者数组的一部分进行排序。也可以使用此方法用给定的比较器对对象数组进行排序Arrays.toString()打印数组的内容
如果想要复制整个数组或其中一部分到另一个数组可以调用 System.arraycopy()方法。此方法从源数组中指定的位置复制指定个数的元素到目标数组里。这无疑是一个简便的方法。有时候用 ByteBuffer bulk复制会更快。可以参考这篇文章.
最后所有的集合都可以用T[] Collection.toArray( T[] a ) 这个方法复制到数组中。通常会用这样的方式调用
return coll.toArray( new T[ coll.size() ] );这个方法会分配足够大的数组来储存所有的集合这样 toArray() 在返回值时就不必再分配空间了。
集合与数组的转换
(1) 将数组转换为集合
LsitT asList(T... a);//返回一个受指定数组支持的固定大小的列表。
把数组变成List集合的好处可以使用集合的思想和方法来操作数组中的元素。如containsgetindexOfsubList等方法。
PS:
将数组转换成集合不可使用集合的增删方法因为数组的长度是固定的。如果进行增删操作则会产生UnsupportedOperationException的编译异常。如果数组中的元素都是对象则变成集合时数组中的元素就直接转为集合中的元素。如果数组中的元素都是基本数据类型那么会将该数组作为集合中的元素存在。
(2) 集合转数组
查找
int binarySearch()使用二分搜索法来搜索指定的 byte 型数组以获得指定的值
判断
boolean equals(Object[] a, Object[] a2)判断指定的两个数组是否相等
排序
void sort()对指定的数组按数字升序进行排序。
复制
T T[] copyOf(T[] original, int newLength) 复制指定的数组截取或用 null 填充如有必要以使副本具有指定的长度。
填充
void fill(Object[] a, Object val) 将指定的 Object 引用分配给指定 Object 数组的每个元素。
其他方法
toString(Object[] a)返回指定数组内容的字符串表示形式。int hashCode(Object[] a) 基于指定数组的内容返回哈希码。
package com.heima.test;import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;public class Test {public static void main(String[] args) {System.out.println(1、将数组转成集合);System.out.println(-------------------);// asList()将数组转换为集合ListInteger list Arrays.asList(87, 67, 65, 544);for (Integer i : list) {System.out.println(i);}System.out.println(2、二分查找);System.out.println(-------------------);// binarySearch()二分查找int[] a { 23, 45, 67, 8, 32, 45, 6, 7, 85, 54, 3, 432 };int index Arrays.binarySearch(a, 45);System.out.println(index);System.out.println(3、排序);System.out.println(-------------------);// sort()排序System.out.println(排序前 Arrays.toString(a));Arrays.sort(a);System.out.println(排序后 Arrays.toString(a));System.out.println(4、集合转成数组);System.out.println(-------------------);// toArray()集合转成数组ArrayListString al new ArrayListString();al.add(java);al.add(javase);al.add(php);al.add(ruby);al.add(android);String[] str al.toArray(new String[al.size()]);System.out.println(Arrays.toString(str));}
}6.3 System.arraycopy()
public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length); src - 源数组srcPos - 源数组中的起始位置dest - 目标数组destPos - 目标数据中的起始位置length - 要复制的数组元素的数量
6.4 Predicate 操作集合
Predicate 谓词对象函数式接口可以使用Lambda表达式作为参数。
test()
Collection的removeIf(Predicate filter)方法批量删除符合filter条件的元素
6.5 Stream 操作集合 A sequence of elements supporting sequential and parallel aggregate operations. Stream是元素的集合这点让Stream看起来用些类似Iterator可以支持顺序和并行的对原Stream进行汇聚的操作
Stream是什么高级迭代器
大家可以把Stream当成一个高级版本的IteratorIterator,用户只能一个一个的遍历元素并对其执行某些操作Stream,用户只要给出需要对其包含的元素执行什么操作
什么是Stream api
jdk8使用流水线的方法处理数据。一堆操作符的集合。
dk8 Stream:是一个集合但是可能接受多个环节的处理。每个环节专门的操作符(处理方法:由于非常简短看起来就像一个符号)
流式 API获取StreamCollection的stream()方法
StreamIntStreamLongStreamDoubleStream
对应的Builder
Stream.BuilderIntStream.BuilderLongStream.BuilderDoubleStream.Builder
Stream
中间方法
方法声明功能描述filter()过滤map()转换mapToXxx()一对一转换flatMap()集合扁平化flatMapToXxx()peek()skip()distinct()去重sorted()排序limit()concat()合并流
末端方法
方法声明功能描述forEach()遍历toArray()将流中的元素转换成数组reduce()合并流中的元素min()最小值max()最大值count()获取流中元素的数量anyMatch()allMatch()nonMatch()findFirst()获取流中的第一个元素findAny()获取流中的任意一个元素
IntStream
方法声明功能描述builder()max()min()sum()count()average()allMatch()anyMatch()map()一对一转换forEach()遍历
