目录
3、 Arrays.ArrayList-----List Arrays.asList(object 1 ....)
一、集合类作用：
用于存放数量不等的对象，容器类。
二、集合相关的类：
集合相关的类都是由Collection和map接口派生而来
1、set----代表无序，不可重复的集合
2、List----代表有序，可以重复的集合
3、Queue---用于模拟队列这种数据结构
4、Map-----代表着具有映射关系的集合（map相关的明日更新）
三、Collection接口：
定义了set、list、queue通用方法，添加元素、删除元素、返回元素个数、遍历元素，判断包含某个元素等。
1、Interator迭代器
Interator（迭代器）是一个接口，用于遍历Collection中的元素
* boolean hasNext（） 判断集合是否集合完，集合完之后返回false * Object next（） 返回集合中的下一个元素 * void remove 删除集合里边上一次next方法返回的元素
ArrayList c = new ArrayList();
c.add("1");
c.add("2");
c.add("3");
c.add("4");
//遍历集合
for (Object obj : c){//循环遍历
System.out.println(obj);
// if (obj.equals("4")){//循环时候不能改变值，
// c.remove(obj);
// }
}
Iterator iterator = c.iterator();
while (iterator.hasNext()){
Object obj = iterator.next();
System.out.println(obj);
if(obj.equals("2")){
// c.remove("2");//报错
iterator.remove();//使用迭代器删除
}
}
System.out.println(c);2、Set：
* HashSet :元素不可重复
* 不能保证元素的排列顺序
* 集合元素的值可以为null
* 是非线性安全的，在多线程下使用JUC来保证同步
* LinkedHashSet （HashSet的子类）
* 采用链表维护元素插入顺序
* TreeSet ：支持两种排序方式，以保证元素的顺序、比HashSet多了一些方法
* 返回集合中的第一个（最后一个）元素
* 放回集合中位于指定元素之前（之后）的元素
* 放回集合中某个限定范围内的元素组成的子集
TreeSet ss = new TreeSet();//自动排序，
ss.add(78);
ss.add(72);
ss.add(88);
ss.add(98);
ss.add(70);
System.out.println(ss);//基于自然排序方法
System.out.println(ss.first() + "-" + ss.last());//获取第一个元素和最后一个元素
System.out.println(ss.lower(70) + "-" + ss.higher(78));//传出比lower小的值和比higher的一个值
System.out.println(ss.headSet(72));//获取比72小的值构成的子集
System.out.println(ss.tailSet(72));//获取大于等于72的子集采用红黑树的数据结构存储元素，支持自然排序和定制排序两种排序
* 自然排序：
* 1、添加时，调用元素的compareTo方法比较元素的大小，并按照升序排列元素
* 2、添加到TreeSet中的对象必须实现Compareable接口，该接口定义了compareTo
* 3、Java提供的很多数据均已经实现了Comparable接口，例如String、Data等
* 定制排序：
//自然排序
TreeSet name = new TreeSet();
name.add("z");
name.add("b");
name.add("c");
name.add("r");
name.add("f");
System.out.println(name);
//定制排序
TreeSet nums = new TreeSet(new Comparator() {//从大到小
@Override
public int compare(Object o1, Object o2) {
Number n1 = (Number) o1;
Number n2 = (Number) o2;
if (n1 ==null && n2 == null){
return 0;
}
else if (n1 == null){//如果n1=null、n2不是，则认为n1大于n2
return -1;
}else if (n2 == null){
return 1;//此时认为N1更小
}else if (n1.doubleValue() > n2.doubleValue()){//将n1\n2转换为double
return 1;//此时认为N1更小
}else if (n1.doubleValue() < n2.doubleValue()){//将n1\n2转换为double
return -1;//此时认为N1更小
}else {
return 0;
}
}
});
nums.add(null);
nums.add(78);
nums.add(72);
nums.add(88.5);
nums.add(98);
nums.add(70);
System.out.println(nums);3、Queue
用于模拟队列，是一种先进先出的容器
* boolean add（Object e） 将元素加入到队列尾部
* Object element（） 获取队列头部的元素，但不删除元素
* boolean offer（Object e）将元素加入队列尾部，当使用有容量限制的队列时，此方法更好
* Object peek（）获取队列头部的元素，但不删除元素，当队列为空时候返回null
* Object poll（）获取队列头部元素，并删除该元素，当队列为空时候返回null
* Object remove（）获取队列头部元素，并删除该元素
/**
* Queue
*/
Queue queue = new ArrayDeque();
//入队
queue.offer("Lucy");
queue.offer("Jon");
queue.offer("Mary");
queue.offer("Lily");
System.out.println(queue);
//返回队头
System.out.println(queue.peek());
System.out.println(queue);
//返回头部删除
while (queue.size()>0){
System.out.println(queue.poll());
}
System.out.println(queue);
01、Queue实现类
* Deque接口代表双端队列，允许从队列头/尾的任何一端，来进行入队/出队的操作，甚至还支持入栈/出栈的操作，Deque在Queue基础上增加两种方法：
* boolean offerFirst（Object e）
* boolean offerlast（Object e）
//双端队列
Deque queue1 = new ArrayDeque();
queue1.offer("Lucy");
queue1.offer("Jon");
queue1.offer("Mary");
queue1.offer("Lily");
System.out.println(queue1);
queue1.offerFirst("Fan");//头部插入
System.out.println(queue1);
queue1.offerLast("Zhang");//尾部插入
System.out.println(queue1);
System.out.println(queue1.peekFirst());//获取头
System.out.println(queue1.peekLast());//获取尾巴
while (queue1.size()>0){//队尾出队
System.out.println(queue1.pollLast());
}
while (queue1.size()>0){//队头出队
System.out.println(queue1.pollFirst());
}
//栈.
Deque stack = new ArrayDeque();
stack.push("张三");
stack.push("李四");
stack.push("王五");
stack.push("老六");
System.out.println(stack);
//栈先入后出
while (stack.size()>0){
System.out.println(stack.pop());
}
System.out.println(stack); * ArrayDeque、LinkedList是Deque接口的实现类，前者采用数组实现双端队列，而后者采用链表结构实现双端队列
* LinkedList
* 有序集合
* LinkedList采用链表结构实现有序集合
* ArrayList采用数组实现（初始长度为10）
* 双端队列
* LinkedList采用链表结构实现双端队列
* ArrayDeque采用数组实现（初始长度为16）
02、数组 于 链表 对比
* 数组需要占用连续的存储空间，访问效率高，增删效率低
* 链表不占连续空间，增删效率高，访问效率低，是以指针方式维护元素的顺序，即上一个元素会指向下一个元素。
4、List ：
代表有序的集合，提供根据索引来访问集合的方法
* 将元素插入到集合中指定的索引处，
* 将指定索引处的元素从集合中删除
* 从集合中返回指定索引处的元素
* 返回某个元素在集合中的索引值
* 从集合中、返回起始索引和结束索引之间的元素组成的子集
List list1 = new ArrayList();
list1.add("Tom");
list1.add("Tony");
list1.add("Lisa");
list1.add("Jon");
list1.add("Tony");//添加一个重复元素
System.out.println(list1);//打印顺序为添加元素顺序，说明有序可重复的集合
list1.add(1,"Lucy");//在1位置添加一个元素
System.out.println(list1);
list1.remove(1);//删除位置1的元素
System.out.println(list1);
//指定索引获取元素
for (int i = 0;i<list1.size();i++){
System.out.println((i+1) + ": " + list1.get(i));
}
System.out.println(list1.subList(1,3));//获取子集,1<=<list<3
System.out.println(list1.indexOf("Tony") + ", " + list1.lastIndexOf("Tony"));
ListIterator iterator = list1.listIterator();
while (iterator.hasNext()){//从前往后遍历
System.out.println(iterator.next() + " ");
}
System.out.println();
while (iterator.hasPrevious()){//从后往前遍历
System.out.println(iterator.previous() + " ");
}
System.out.println();
//由小到大排序
list1.sort(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
String s1 = (String) o1;
String s2 = (String) o2;
if (s1 ==null && s2 == null){
return 0;
}else if (s1 == null){//如果n1=null、n2不是，则认为n1大于n2
return -1;
}else if (s2 == null){
return 1;//此时认为N1更小
}else {
return s1.compareTo(s2);
}
}
});
System.out.println(list1);
ArrayList names = new ArrayList();
// names.add("Lily");
// int[] nums = {10,20,30,40,50};//int数组不可以自动装箱成为Integer数组
Integer[] nums = {10,20,30,40,50};
List numList = Arrays.asList(nums);//里面需要一个对象一个对象数组，当传入int后，认为是一个数组，而不是对象数组
System.out.println(numList); * List提供了listIterator（）方法，以返回一个ListIterator对象
* ListIterator接口继承于Iterator，该接口增加了如下的方法
* boolean hasPrevious（） 判断迭代器指向元素是否有上一个元素
* Object previous（） 返回迭代器所指向的元素的上一个元素
* void add（Object0） 在迭代器所指向的元素位置插入一个元素
01、ArrayList
* ArrayList是基于数组实现的List接口
* ArrayList内部封装了一个长度可变的Object[]数组
* 默认该数组的初始长度为10，也可以通过构造器参数显示指定其初始长度
* 每当添加元素的个数超出了数组的长度，AeeayList会自动对长度进行扩展
02、Vector
* Vector是基于数组实现，用法与ArrayList用法相同
* Vector是线程安全的，ArrayList是非线程安全的
* Vector有保证线程安全的开销，所以性能低
* Vector的子类Stack，用于模拟栈这种数据结构
3、 Arrays.ArrayList-----List Arrays.asList(object 1 ....)
* 该方法可以把多个对象或一个对象变成一个List集合，
* 实际返回类型是Arrays的内部类，名字也叫ArrayList
* Arrays.ArrayList是一个固定的长度的集合，可以遍历，但不能增加、和删除
4、Map：存放成对数据的
* 1、Map用于保存具有映射关系的数据（Key -Value）
* 2、key和value之间存在单向一对一的关系，通过制定的key，总能找到确定的value
* 3、Map的key不允许重复，同一个Map的任何两个key通过equals比较总返回false
/**
* Map
*/
Map map = new HashMap();//不保证数据的顺序
map.put("Jon",65);
map.put("Lily",75);
map.put("Ton",85);
System.out.println(map);
//key不重复，但是Value可以重复
map.put("Mar",85);
System.out.println(map);
//Key重复之后会覆盖
map.put("Mar",80);
System.out.println(map);
//从map中获取数据
System.out.println(map.get("Mar"));
//判断map中存不存在某个key
System.out.println(map.containsKey("Mar"));
//判断是否存在某个值
System.out.println(map.containsValue("85"));
//删除数据根据Key
map.remove("Mar");
System.out.println(map);
//获取所有的数据
//底层Entry封装一对数据，调用entrySet方法获取到所有的数据
//entrySet()遍历所有的Map
for (Object entry : map.entrySet()){//遍历
Map.Entry e = (Map.Entry) entry;//强转
System.out.println(e.getKey()+ ": " + e.getValue());
}
//keySet遍历所有的Key
for (Object key : map.keySet()){//遍历转
System.out.println(key+ ": " + map.get(key));
}
//values遍历所有的Value
for (Object value : map.values()){
System.out.println(value);
}四、Map实现类
1、HashMap
HashMap是Map接口的典型实现（线程不安全，性能高）
* HashMap非线程安全，性能高于HashTable
* HashMap允许null作为key/value，而HashTable不允许null
/**
* HashMap
*/
Map map1 = null;
map = new Hashtable();
// map.put("Tony",null);//报错
// map.put(null,null);//报错
map1 = new HashMap();
map1.put("Tony",null);
map1.put(null,null);
System.out.println(map1);
for (Object key : map1.keySet()){
System.out.println(key+ ": " + map1.get(key));
}2、LinkedHashMap
采用链表维护键值对的顺序
* LinkedHashMap采用双向链表维护键值对的顺序
* 相对于HashMap，LinkedHashMap在迭代时性能高，在插入时候性能低
/**
* LinkedHashMap----有序
*/
map1 =new LinkedHashMap();
map1.put("语文",50);
map1.put("数学",60);
map1.put("英语",53);
map1.put("历史",40);
System.out.println(map1);
for (Object key : map1.keySet()){
System.out.println(key+ ": " + map1.get(key));
}3、HashTable
HashTable 是古老的Map（线程安全，性能低）
4、Propertie
常用用于处理属性文件；（线程安全，性能低）
* 属性文件：存储属性名与属性值的文件，例如“.ini、.properties文件”
*Properties:
* 擅长处理属性文件，可以很方便的实现对属性文件的读写操作。
* 提供load()方法加载属性文件、store()方法保存属性文件。
* 提供getProperty()方法读取某个属性、setProperty()方法修改某个属性的值。
5、SortedMap
SortedMap是Map的子接口（两种排序方式）
6、TreeMap
*采用红黑树结构实现了SortedMap。在存储键值对时候，按照key键值对排序
* 自然排序
* 对key进行比较，根据key按照从小到大的顺序排序
* 对所有的key应该是同一个类型，请必须实现Comparable接口
TreeMap map = null;
//自然排序方式
map = new TreeMap();
map.put("Lily",80);
map.put("Mary",90);
map.put("Join",70);
map.put("Job",75);
//对key进行比较，根据key按照从小到大的顺序排序
System.out.println(map);
//获取第一个和最后一个key
System.out.println(map.firstKey() + ", " + map.lastKey());
//指定某一个key，要他前面或者后面的key
System.out.println(map.lowerKey("Mary") + ", " + map.higherKey("Join"));
//返回Map的子集
System.out.println(map.headMap("Join"));//返回指定的Key前面的值
System.out.println(map.tailMap("Join"));//返回指定的key后面的值
// System.out.println(map.subMap("Mary","Join"));//返回大于等于Mary，小于Job的子集
//定制排序算法
map = new TreeMap(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
String s1 = (String) o1;
String s2 = (String) o2;
if(s1 == null && s2 == null){
return 0;
}else if (s1 == null){
return 1;
}else if (s2 == null){
return -1;
}else {
return s1.compareTo(s2) * (-1);
}
}
});
map.put("Lily",80);
map.put("Mary",90);
map.put("Join",70);
map.put("Job",75);
System.out.println(map); * 定制排序
* 创建TreeMap时，传入一个Comparator类型的对象
* 该对象负责对所有的key进行比较，此时不要求Key实现Comparator接口
281
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
