黑马程序员技术交流社区
标题: 【太原校区】Java集合 [打印本页]
作者: Dream丿拼 时间: 2018-5-3 17:00
标题: 【太原校区】Java集合
Java集合
数组作为容器，可以存储基本数据类型，也可以存储引用数据类型，数组一旦定义出来，长度就固定了，而且也只能存储引用数据类型，用起来不太方便，所以就引出了集合的概念。
集合
集合的长度是可变的，集合中可以存储不同的数据类型，但是集合不能存储基本数据类型
集合中的方法
Collection: 包括 list 和 set
a/添加功能 boolean add(Object obj):添加一个元素
boolean addAll(Collection c):添加一个集合的元素 (给一个集合添加进另一个集合中的所有元素)
[Java] 纯文本查看 复制代码
Collection con = new ArrayList();
con.add(s1);
con.add(s2);
con.add(s3);
Collection con2 = new ArrayList();
con2.add(Integer.valueOf(1));
con2.add(2);
con2.add(3);
con.addAll(con2);
b/删除功能
void clear():移除所有元素
boolean remove(Object o):移除一个元素
boolean removeAll(Collection c):移除一个集合的元素(移除一个以上返回的就是true) 删除的元素是两个集合的交集元素 ,如果没有交集元素 则删除失败 返回false
[Java] 纯文本查看 复制代码
Collection collection = new ArrayList();
<span class="space" style="white-space:pre;display:inline-block;text-indent:2em;line-height:inherit;"> </span>collection.add("关羽");
collection.add("张飞");
collection.add("赵云");
collection.add("马超");
collection.add("魏延");
boolean b = collection.remove("魏延");
[Java] 纯文本查看 复制代码
<span style="background-color:transparent;"> </span>A 集合 removeAll B 集合，如果两个集合没有交集元素，则移除失败
两个集合中的元素都不会发生变化
如果说有交集元素， A 集合 removeAll B 集合 那么A中就会移除掉 交集元素 B集合不发生变化，移除成功
c/判断功能 boolean contains(Object o)：判断集合中是否包含指定的元素
boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(这个集合 包含 另一个集合中所有的元素才算包含 才返回true)
boolean isEmpty()：判断集合是否为空
d/获取功能，接口 Iterator<E> 迭代器（可以理解为遍历）
boolean hasNext()
如果仍有元素可以迭代，则返回 true
[Java] 纯文本查看 复制代码
Iterator iterator = collection.iterator();
while (iterator.hasNext()){
Object next = iterator.next();
System.out.println(next);}
e/长度功能
int size():元素的个数
f/交集功能
A集合对B集合取交集，获取到的交集元素在A集合中。返回的布尔值表示的是A集合是否发生变化
boolean retainAll(Collection c):获取两个集合的交集元素(交集：两个集合都有的元素)
g/把集合转换为数组
toArray( ) System.out.println(collection.size());
[Java] 纯文本查看 复制代码
Collection collection = new ArrayList();
collection.add(1);
collection.add(2);
collection.add(3);
collection.add(4);
collection.add(5);
collection.add(6);
Object[] toArray();
Object[] objects = collection.toArray();
但是要注意的是通过aslist方法把数组转换成集合后，这个集合就不能再添加元素了
[Java] 纯文本查看 复制代码
Integer[] integers = {1, 2, 3, 7};
List<Integer> integers1 = Arrays.asList(integers);
// integers1.remove(1);//报错
//integers1.add(6);//报错
Collection 集合 对应一个工具类 Collections[Java] 纯文本查看 复制代码
ArrayList<Integer> list = new ArrayList<>();
list.add(3);
list.add(6);
list.add(5);
list.add(2);
list.add(1);
list.add(9);
list.add(10);
Comparator<Integer> comparator = new Comparator<Integer>() {
@Override
public int compare(Integer s1, Integer s2) {
return s1 - s2;
}
};
//Lambda 表达式 需要 函数式接口的支持，使用Lambda表达式可以有效的的节省代码，但应用时一定要细心将表达式补充完整。
//函数式接口 接口里面只有一个抽象方法就是函数式接口
// Comparator<Integer> com = (x, y) -> x - y;
//Lambda 表达式 要一种函数式接口的支持 排序
list.sort(comparator);
Collections.sort(list);
System.out.println(list);
二分查找，前提是集合的元素有序
int i = Collections.binarySearch(list, 10);
System.out.println(i);
获取集合中 最大值和最小值
Integer max = Collections.max(list);
Integer min = Collections.min(list);
反转集合中的元素
Collections.reverse(list);
System.out.println(list);
随机打乱集合中的元素顺序
Collections.shuffle(list);
System.out.println(list);
接口 Iterator<E>
通过迭代器是遍历集合的一种方式
boolean hasNext()
如果仍有元素可以迭代，则返回 true。
next()
返回迭代的下一个元素。
[Java] 纯文本查看 复制代码
Iterator iterator = collection.iterator();
while (iterator.hasNext()){
Object next = iterator.next();
System.out.println(next);}
获取集合长度的方法 size()System.out.println(collection.size());
虽然集合可以存储任意数据的引用数据类型但一般来说，我们不会给集合中存储的多种类型的元素，我们一般只在集合里面就存储一种类型
List集合: 包括 ArrayList Vector LinkedList允许元素重复
void add(int index,E element): 在指定索引处添加元素
E remove(int index):移除指定索引处的元素 返回的是移除的元素
E get(int index):获取指定索引处的元素
E set(int index,E element):更改指定索引处的元素 返回的而是被替换的元素
subList（首索引，尾索引），根据首位索引截取集合中的元素
List的三个子类的特点 ArrayList 底层数据结构是数组，增删慢，查询快 线程不同步，数据不安全，效率高
Vector 底层数据结构也是数组，增删慢 查询快 线程同步，数据安全，效率慢
LinkedList 底层数据结构是链表，增删快 查询慢 线程不同步，数据不安全效率高
我们根据需要，如果对数据安全要求较高，建议采用Vector
还要考虑操作中查询多还是增删多
数组特点: 查询快 , 增删慢
链表特点: 查询慢 , 增删快
ListIteratorListIterator继承了Iterator，所以也可以使用Iterator中的方法
而ListIterator的特有功能有
boolean hasPrevious(): 是否存在前一个元素
E previous(): 返回列表中的前一个元素
用这两个方法反向遍历集合
因为指针默认在集合开始，只有先将指针放到末尾才能反向遍历
[Java] 纯文本查看 复制代码
ListIterator<String> iterator = list.listIterator();
while (iterator.hasNext()){
System.out.println( iterator.next());
}
System.out.println("---------------------");
while (iterator.hasPrevious()){
System.out.println(iterator.previous())
List集合的遍历方式
如果说你用迭代器去遍历集合，在遍历的中间，如果你想往集合里面加元素，或者说删除元素
那就要用迭代器自己的 添加和删除方法，不要用集合的添加和删除方法，不然就会报并发修改异常，//ConcurrentModificationException，所以经常采用for循环来遍历
[Java] 纯文本查看 复制代码
方式1：
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
System.out.println("----------------------------------------");
方式2：采用List 特有的迭代器
ListIterator<String> stringListIterator = list.listIterator();
while (stringListIterator.hasNext()) {
System.out.println(stringListIterator.next());
}
System.out.println("----------------------------");
方式3：for 循环遍历//我们最常用for循环来遍历
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
ArrayList他的底层数据结构是数组，所以 查询快，增删慢
数据是有序的，存的顺序和取得顺序一样
[Java] 纯文本查看 复制代码
ArrayList<String> list = new ArrayList<>();
list.add("唐三藏");
list.add("孙大圣");
list.add("猪悟能");
list.add("沙悟净");
list.add("小白龙");
list.add("唐三藏");
list.add("孙大圣");
list.add("猪悟能");
list.add("沙悟净");
list.add("小白龙");
//重新拿出一个集合，遍历第一个集合，去掉重复的元素
ArrayList<String> newList = new ArrayList<>();
for (int i = 0; i < list.size(); i++) {
String ele = list.get(i);
if (!newList.contains(ele)) {
newList.add(ele);
}
}
System.out.println(newList);
System.out.println(list);
其中contains这个方法底层调用了equals方法，默认比较的是地址值，所以当两个对象相同时，我们要重写equals方法
VectorinsertElementAt(E obj, int index)在指定索引的位置插入一个元素
indexOf(Object o)返回指定元素的一次出现的索引
lastElement()获取集合中最后一个元素
firstElement()获取集合中第一个元素
Vector 特有的一个遍历方式
Enumeration<String> elements = v.elements();
boolean hasMoreElements()
测试此集合是否包含更多元素。
E nextElement()
返回此集合的下一个元素，如果此集合至少有一个元素可以返回。
LinkedListvoid addFirst(E e)在此列表的开始处插入指定的元素。
void addLast(E e)将指定的元素列表的结束。
getFirst()返回此列表中的第一个元素。
getLast()返回此列表中的最后一个元素。
boolean offer(E e)将指定的元素添加到列表的尾部（最后一个元素）。
boolean offerFirst(E e)在列表的前面插入指定的元素。
boolean offerLast(E e)在列表的结尾插入指定的元素。
void push(E e)将一个元素放在集合最前端
Arrays工具类的asList()方法将数组元素转换成集合，得到的集合长度是不可变的 你不能往这个转换后的集合中 添加元素（add） 和 删除元素(remove)， 只能获取元素(get)
数据结构的栈和队列
数据结构的数组和链表
set接口：包含HashSet LinkedHashSet TreeSetset集合的特点：元素是无序的，唯一的HashSet（无序，唯一）HashSet集合底层结构是哈希表，哈希表底层维护的是数组和链表
HashSet集合靠元素重写hashCode和equals方法来保证元素的唯一性
元素有序靠链表保证
元素唯一靠哈希表保证
如果元素不重写这两个方法，就无法保证唯一性
String和Integer默认重写了hashCode方法和equals方法
HashSet存储元素保证元素唯一性图解
TreeSet（排序，唯一）TreeSet 底层数据结构是二叉树结构，元素唯一，而且还能排序
二叉树存储数据保证元素唯一性的原理图解
排序的方法有两种
1。自然排序 空参构造采用的就是自然排序
采用自然排序，是元素实现了Comparaeble接口 重写了compareTo方法
如果元素不重写接口中的方法。那么存储元素时就会报错
存元素的时候，根据compareTo方法的返回值来决定
返回0：就不存
返回正数：往树的根节点的右边存
返回负数：往树的根节点的左边存
[Java] 纯文本查看 复制代码
string和Integer默认实现了Compareble和重写了compareTo方法
TreeSet<String> tree = new TreeSet<>();
tree.add("b");
tree.add("a");
tree.add("b");
tree.add("c");
tree.add("d");
tree.add("a");
System.out.println(tree);
2。比较器排序 有参构造采用的就是比较器排序
创建TreeSet对象的时候，传进来一个比较器的子类对象
接口 Comparator<T> 比较器
int compare(T o1, T o2) 比较方法比较用来排序的两个参数
根据子类对象重写比较器中的compare方法，根据方法返回值的正负和0来排序元素和去重
对于自定义类，采用匿名内部类的方法去重写方法传参数比较方便，当然自己定义一个子类也是可以的
[Java] 纯文本查看 复制代码
TreeSet t = new TreeSet<>(new Comparator<Integer>() {
@Override
public int compare(Integer s1, Integer s2) {
return s1 - s2;
}
});
t.add(6);
t.add(6);
t.add(3);
t.add(2);
t.add(1);
t.add(4);
t.add(5);
t.add(4);
t.add(3);
System.out.println(t);
}//[1,2,3,4,5,6]
LinkedHashSet（有序，唯一）LinkedhashSet 底层数据结构是链表和哈希表
元素有序靠链表保证，元素唯一靠哈希表保证
[Java] 纯文本查看 复制代码
LinkedHashSet<Integer> list = new LinkedHashSet<>();
list.add(Integer.valueOf(1));
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
System.out.println(list);//[1, 2, 3, 4, 5]
用自然排序：采用自然排序 要求元素必须实现Comparable接口
然后重写compareTo方法 根据自己的排序方式 返回正负或0
用比较器去排序：采用匿名内部类的方式去传入比较器 的子类对象，重写compare方法
接口 Map<K,V>将键映射到值的对象，一个映射不能包含重复的键，每个键最多映射一个值，K为键。V为值。map集合中，一个键只对应一个值，当键相同时值会覆盖，其中允许使用null键与null值，map集合的数据结构只和键有关，与值无关常用方法HashMap<String, String> hm = new HashMap<>(); String put = hm.put("老大", "呵呵");//添加元素
String put2 = hm.put("张三", "哈哈");//键相同，值覆盖
String put3 = hm.put("张三", "呵呵");//输出结果：张三呵呵
hm.remove("老大");//移除一个键值对hm.clear();//清空一个集合boolean b = hm.containsKey("张三");//判断一个集合是否包含指定键
boolean v = hm.containsValue("哈哈");//判断一个集合是否包含指定值
boolean empty = hm.isEmpty();//判断一个集合是否为空
类 HashMap<K,V>允许插入null键和null值HashMap和Hashtable的区别:
HashMap: 非同步，线程不安全,效率高.允许null值和null键
Hashtable: 同步，线程安全 , 效率低.不允许null值和null键
获取所有值的集合
[Java] 纯文本查看 复制代码
Collection<String> values = hm.values();
for(String v:values){
System.out.println(v);
}
获取集合长度hm.size();
遍历集合有两种方法1。通过键来找值
[Java] 纯文本查看 复制代码
Set<Integer> keys = hm.keySet();//获取所有键的集合
for (Integer key : keys) {
String value = hm.get(key);//通过键，获取值
System.out.println(key + "====" + value);
}
2。直接获取 键值对 对象 ，用对象里面的方法获取键跟值
[Java] 纯文本查看 复制代码
Set<Map.Entry<Integer, String>> entries = hm.entrySet();
for (Map.Entry<Integer, String> en : entries) {
System.out.println(en.getKey() + "===" + en.getValue());
}
类 LinkedHashMap<K,V>底层数据结构是链表和哈希表，元素有序且唯一其特点是保存了记录的插入顺序，先得到的记录先插入，LinkedHashMap取的顺序就是自己存的顺序
类 TreeMap<K,V>
TreeMap集合不允许插入null键，可以插入null值TreeMap集合的两种排序方法：自然排序和比较器排序方法与TreeMap大致相同
案例演示：斗地主，经常拿来看看，复习一下
使用ArrayList
[Java] 纯文本查看 复制代码
package org.westos.demo4;
import java.util.ArrayList;
import java.util.Collections;
public class MyTest7 {
public static void main(String[] args) {
//模拟斗地主的发牌和看牌
// 模拟斗地主洗牌和发牌，牌没有排序
//1.定义一个牌盒 来装牌
//2.生成54张牌装进牌盒
//3.洗牌
//4.发牌
//5.看牌
//1.创建牌盒子
ArrayList<String> pokerBox = new ArrayList<>();
//2.生成牌 ，装进牌盒
String[] colors = {"♣", "♠", "♥", "◆"};
String[] nums = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"};
for (String color : colors) {
for (String num : nums) {
String pai = color.concat(num);
pokerBox.add(pai);
}
}
//添加大小王
pokerBox.add("★");
pokerBox.add("☆");
//洗牌
Collections.shuffle(pokerBox);
Collections.shuffle(pokerBox);
Collections.shuffle(pokerBox);
// System.out.println(pokerBox);
// 发牌
ArrayList<String> 底牌 = new ArrayList<>();
ArrayList<String> 周星驰 = new ArrayList<>();
ArrayList<String> 吴宗宪 = new ArrayList<>();
ArrayList<String> 曾志伟 = new ArrayList<>();
//发牌的算法
// 周星驰 0 3 6 9
//// 吴宗宪 1 4 7 10
//// 曾志伟 2 5 8 11
for (int i = 0; i < pokerBox.size(); i++) {
//留底牌
if (i >=pokerBox.size() - 3) {
底牌.add(pokerBox.get(i));
} else if (i % 3 == 0) {
周星驰.add(pokerBox.get(i));
} else if (i % 3 == 1) {
吴宗宪.add(pokerBox.get(i));
} else if (i % 3 == 2) {
曾志伟.add(pokerBox.get(i));
}
}
//看牌
lookPoker("周星驰",周星驰);
lookPoker("吴宗宪",吴宗宪);
lookPoker("曾志伟",曾志伟);
lookPoker("底牌",底牌);
}
private static void lookPoker(String name, ArrayList<String> list) {
System.out.println(name);
for(String s:list){
System.out.print(s+" ");
}
System.out.println();
}
}
使用HashMap
[Java] 纯文本查看 复制代码
package org.westos.demo4;
import sun.security.action.PutAllAction;
import java.util.*;
public class MyTest8 {
public static void main(String[] args) {
//创建牌盒
HashMap<Integer, String> pokerBox = new HashMap<>();
//生成牌，往牌盒里面装牌
String[] colors = {"♣", "♠", "♥", "◆"};
String[] nums = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"};
int index = 0;//定义索引
for (String num : nums) {
for (String color : colors) {
String poker = num.concat(color);
pokerBox.put(index, poker);
index++;
}
}
//手动添加两张王
pokerBox.put(index, "★");
index++;
pokerBox.put(index, "☆");
//System.out.println(pokerBox);
//洗牌
Set<Integer> integers = pokerBox.keySet();
ArrayList<Integer> suoyin = new ArrayList<>();
for (Integer i : integers) {
suoyin.add(i);
}
// System.out.println(suoyin);
Collections.shuffle(suoyin);
Collections.shuffle(suoyin);
Collections.shuffle(suoyin);
//发牌
TreeSet<Integer> 底牌 = new TreeSet<Integer>();
TreeSet<Integer> 周星驰 = new TreeSet<Integer>();
TreeSet<Integer> 吴宗宪 = new TreeSet<Integer>();
TreeSet<Integer> 曾志伟 = new TreeSet<Integer>();
for (int i = 0; i < suoyin.size(); i++) {
if (i >= suoyin.size() - 3) {
底牌.add(suoyin.get(i));
} else if (i % 3 == 0) {
周星驰.add(suoyin.get(i));
} else if (i % 3 == 1) {
吴宗宪.add(suoyin.get(i));
} else if (i % 3 == 2) {
曾志伟.add(suoyin.get(i));
}
}
//看牌
lookPoker("底牌", 底牌, pokerBox);
lookPoker("周星驰", 周星驰, pokerBox);
lookPoker("吴宗宪", 吴宗宪, pokerBox);
lookPoker("曾志伟", 曾志伟, pokerBox);
}
private static void lookPoker(String name, TreeSet<Integer> ts, HashMap<Integer, String> pokerBox) {
System.out.println(name);
for (Integer in : ts) {
System.out.print(pokerBox.get(in));
}
System.out.println();
}
}
作者: Dream丿拼 时间: 2018-5-3 17:13
Hello, World!
| 欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) |
黑马程序员IT技术论坛 X3.2 |