java集合
集合类存放的都是对象的引用，而非对象本身，出于表达上的便利，我们称集合中的对象就是指集合中对象的引用（reference)。
集合类型主要有3种：set(集）、list(列表）和map(映射)。
集合的概念
集合是一个动态的数组，
数组的长度是不可变的，集合长度是可变的
Collection接口概述
Collection表示一组对象，这些对象也被称为Collection的元素。一些Collection允许有重复的元素（例如List），但是另一些则不允许有重复的元素，即可为无序的（如Set）。
List集合特点
元素有序
每一个元素都存在一个索引
元素可以重复。
Map集合的特点
元素无序
元素通过键值对的方式进行存储
键不可重复，值可以重复
Set集合的特点
元素无序
元素是通过连表进行存储的
元素不可重复
ArrayList集合概述
集合只能存储引用数据类型
ArrayList是顺序结构
特点：查询快，增删慢、线程不安全，效率高
ArrayList示例
// 创建ArrayList
ArrayList list = new ArrayList();
// 将“”
list.add("1");
list.add("2");
list.add("3");
list.add("4");
// 将下面的元素添加到第1个位置
list.add(0, "5");
// 获取第1个元素
System.out.println("the first element is: "+ list.get(0));
// 删除“3”
list.remove("3");
// 获取ArrayList的大小
System.out.println("Arraylist size=: "+ list.size());
// 判断list中是否包含"3"
System.out.println("ArrayList contains 3 is: "+ list.contains(3));
// 设置第2个元素为10
list.set(1, "10");
// 通过Iterator遍历ArrayList
for(Iterator iter = list.iterator(); iter.hasNext(); ) {
System.out.println("next is: "+ iter.next());
}
LinkedList概述
LinkedList底层数据结构是链表
特点查询慢，增删快，线程不安全，效率高
LinkedList示例
LinkedList llist = new LinkedList();
//---- 添加操作 ----
// 依次添加1,2,3
llist.add("1");
llist.add("2");
llist.add("3");
// 将“4”添加到第一个位置
llist.add(1, "4");
// 删除“栈顶元素”
System.out.println("llist .pop():"+llist .pop());
// 取出“栈顶元素”
System.out.println("llist .peek():"+llist .peek());
// 打印“栈”
System.out.println("llist :"+stack);
// 删除(队列的第一个元素)
System.out.println("llist.remove():"+llist.remove());
// 读取(队列的第一个元素)
System.out.println("llist.element():"+llist.element());
// 打印“队列”
System.out.println("llist:"+llist);
// 输出大小
System.out.println("size:"+llist.size());
Map集合的概述
（1）Map是一个存储键值对元素的集合。
（2）将键映射到值的对象。一个映射不能包含重复的键，每个键最多只能映射到一个值。
（3）Map集合和Collection集合的区别：
Map集合存储的元素是成对出现的（键值对）。MAP集合的键是唯一的，值是可重复的。
Collection集合存储的元素是单独出现的。Collection集合的儿子Set是唯一的，List是可重复的。
Map集合的数据结构只针对键有效，跟值无关。
Collection集合的数据结构是针对元素有效。
HashMap集合概述
1、HashMap是可以序列化的。是线程不安全的。
2、HashMap的底层主要是基于数组和链表实现的，它之所以有相当快的查询速度主要是因为它是通过计算散列码来决定存储位置的。
3、HashMap中主要是通过key的hashCode来计算hash值
HashMap示例
// 初始化随机种子
Random r = new Random();
// 新建HashMap
HashMap map = new HashMap();
// 添加操作
map.put("one", r.nextInt(10));
map.put("two", r.nextInt(10));
map.put("three", r.nextInt(10));
// 打印出map
System.out.println("map:"+map );
// 通过Iterator遍历key-value
Iterator iter = map.entrySet().iterator();
while(iter.hasNext()) {
Map.Entry entry = (Map.Entry)iter.next();
System.out.println("next : "+ entry.getKey() +" - "+entry.getValue());
}
// HashMap的键值对个数
System.out.println("size:"+map.size());
// containsKey(Object key) :是否包含键key
System.out.println("contains key two : "+map.containsKey("two"));
System.out.println("contains key five : "+map.containsKey("five"));
// containsValue(Object value) :是否包含值value
System.out.println("contains value 0 : "+map.containsValue(new Integer(0)));
// remove(Object key) ： 删除键key对应的键值对
map.remove("three");
System.out.println("map:"+map );
增强for循环
增强for概述
简化数组和Collection集合的遍历
格式：
for(元素数据类型 变量 : 数组或者Collection集合) {
使用变量即可，该变量就是元素
}
在使用增强for循环的时候要注意判空
TreeMap概述
TreeMap是基于红黑树实现的。
集合中的映射关系是具有一定顺序的，该映射根据其键的自然顺序进行排序或者根据创建映射时提供的Comparator进行排序
TreeMap中不允许键对象是null
TreeMap示例
// 新建TreeMap
TreeMap tmap = new TreeMap();
// 添加“键值对”
tmap.put("a", 101);
tmap.put("b", 102);
tmap.put("c", 103);
tmap.put("d", 104);
tmap.put("e", 105);
System.out.printf("tmap.headMap(\"c\"):\n\t%s\n", tmap.headMap("c"));
System.out.printf("tmap.tailMap(\"c\"):\n\t%s\n", tmap.tailMap("c"));
System.out.printf("tmap.subMap(\"a\", \"c\"):\n\t%s\n", tmap.subMap("a", "c"));
Set集合概述
set集合中的方法和collection中的方法是一样的。
无序性（元素存取的顺序不一致），
元素不重复
HashSet集合概述
HashSet线程不安全，效率高，允许存储null元素，元素无序且唯一
HashSet元素唯一
HashSet示例
// 新建HashSet
HashSet set = new HashSet();
// 将元素添加到Set中
set.add("a");
set.add("b");
set.add("c");
set.add("d");
set.add("e");
// 打印HashSet的实际大小
System.out.printf("size : %d\n", set.size());
// 判断HashSet是否包含某个值
System.out.printf("HashSet contains a :%s\n", set.contains("a"));
System.out.printf("HashSet contains g :%s\n", set.contains("g"));
// 删除HashSet中的“e”
set.remove("e");
TreeSet概述
TreeSet 集合继承于AbstractSet，所以它是一个Set集合，具有Set的属性和方法。
TreeSet基于TreeMap实现的
底层的数据结构是红黑树（平衡二叉树）。
String val;
// 新建TreeSet
TreeSet tSet = new TreeSet();
// 将元素添加到TreeSet中
tSet.add("aaa");
// Set中不允许重复元素
tSet.add("aaa");
tSet.add("bbb");
tSet.add("eee");
tSet.add("ddd");
tSet.add("ccc");
System.out.println("TreeSet:"+tSet);
// 打印TreeSet的实际大小
System.out.printf("size : %d\n", tSet.size());
// 导航方法
// lower(小于)
System.out.printf("lower bbb: %s\n", tSet.lower("bbb"));
// ceiling(大于)
System.out.printf("higher bbb: %s\n", tSet.higher("bbb"));
// headSet()
System.out.printf("headSet(ccc, true): %s\n", tSet.headSet("ccc", true));
System.out.printf("headSet(ccc, false): %s\n", tSet.headSet("ccc", false));
// tailSet()
System.out.printf("tailSet(ccc, true): %s\n", tSet.tailSet("ccc", true));
System.out.printf("tailSet(ccc, false): %s\n", tSet.tailSet("ccc", false));
// 删除“ccc”
tSet.remove("ccc");
泛型概述
泛型就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，然后在使用/调用时传入具体的类型
List<对象> list = new ArrayList<对象>();
list.add(对象);
list.add(对象);
为什么要用使用泛型
1.当我们将一个对象放入集合中，集合不会记住此对象的类型，当再次从集合中取出此对象时，改对象的编译类型变成了Object类型，但其运行时类型任然为其本身类型。
List<Test1> list = new ArrayList<Test1>();
list.add(new Test1("aaa"));
list.add(new Test1("bbb"));
//list.add(new Test2()); // 1 提示编译错误
Lambda概述
Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体。
Lambda基础语法
基本语法:
(parameters) -> expression
或
(parameters) ->{ statements; }
Lambda语法实例
Lambda语法实例
// 1. 不需要参数,返回值为 5
() -> 5
// 2. 接收一个参数(数字类型),返回其2倍的值
x -> 2 * x
// 3. 接受2个参数(数字),并返回他们的差值
(x, y) -> x – y
// 4. 接收2个int型整数,返回他们的和
(int x, int y) -> x + y
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s)
Lambda表达式与常规写法对比
//匿名内部类
Comparator<Integer> cpt = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return Integer.compare(o1,o2);
}
};
TreeSet<Integer> set = new TreeSet<>(cpt);
System.out.println("=========================");
//使用lambda表达式
Comparator<Integer> cpt2 = (x,y) -> Integer.compare(x,y);
TreeSet<Integer> set2 = new TreeSet<>(cpt2);
Lambda表达式的优缺点
优点：
- 简洁。
- 非常容易并行计算。
- 结合 hashmap 的 computeIfAbsent 方法，递归运算非常快。java有针对递归的专门优化。
缺点： - 若不用并行计算，很多时候计算速度没有比传统的 for 循环快
- 不容易调试。
- 若其他程序员没有学过 lambda 表达式，代码不容易让其他语言的程序员看懂。
- 在 lambda 语句中强制类型转换貌似不方便，一定要搞清楚到底是 map 还是 mapToDouble 还是 mapToInt
1274
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
