集合是java中存储对象的容器,不能存储基本类型。大小不固定,可以动态变化,非常适合做元素的增删操作。 只能存储引用类型非要存储基本类型,选择包装类。
1.数组和集合的元素存储的个数问题。
数组定义后类型确定,长度固定
集合类型可以不固定,大小是可变的
2.数组和集合存储元素的类型问题
数组可以存储基本类型和引用类型的数据
集合只能存储引用类型的数据
3.数组和集合适用的场景
数组适合做数据个数和类型确定的场景(存储东南西北,存储男女)
集合适合做数据个数不确定,且要做增删元素的场景
集合的体系结构
先学单列集合
List系列集合:有序、可重复、有索引
ArrayList、LinkedList: 有序、可重复、有索引
Set集合:添加的元素无序、不重复、无索引
HashSet 无序、不重复、无索引
LinkedSet有序、不重复、无索引
TreeSet按着大小默认升序、不重复、无索引
如何约定集合存储的数据类型(集合支持泛型)
学习Collection的api,Collection是单列集合的祖宗,所有的单列集合都继承Collection的方法
Collection<String> list = new ArrayList<>();
//1.集合中添加元素,添加成功返回true,失败返回false
list.add("java");
list.add("Java");
list.add("html");
list.add("html");
//2.清空元素
list.clear();
//3.判断是否为空
list.isEmpty();
//4.获取集合的大小
list.size();
//5.判断集合是否包含某元素
list.contains("java");
//6.删除集合的元素
list.remove("java");
// list.remove(2);不支持索引删除,只支持值删除
//将集合转换成数组
Object[] arr=list.toArray();
将集合转成数组,必须用Object来接收。
集合合并 集合1.addAll(集合2)
Collection<String> c1 = new ArrayList<>();
c1.add("java");
c1.add("html");
Collection<String> c2= new ArrayList<>();
c2.add("spring");
c2.add("ssm");
//把集合2中的元素合并到集合1,集合2中的元素也存在
c1.addAll(c2);
Collection集合的遍历方式
1.第一种迭代器,取元素的时候c1.next() ,如果越界报异常NoSuchElementException
Collection<String> c1 = new ArrayList<>();
c1.add("java");
c1.add("html");
c1.add("css");
//迭代器
Iterator<String> iterator = c1.iterator();
while(iterator.hasNext()){
String next = iterator.next();
System.out.println(next);
}
2.第二种,foreach或者增强for循环,既可以遍历数组,也可以遍历集合。其内部原理是iterator迭代器
for(数据类型 变量名 : 数组或collection集合){
//在此处使用变量
}
快捷键: 数组名或集合名.for
Collection<String> c1 = new ArrayList<>();
c1.add("java");
c1.add("html");
c1.add("css");
//增强for
for (String s : c1) {
System.out.println(s);
}
3.第三种 lambda表达式,通过调用forEach()方法,在方法中new Consumer
Collection<String> c1 = new ArrayList<>();
c1.add("java");
c1.add("html");
c1.add("css");
//lambda表达式,通过调用forEach()方法来遍历
c1.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
//上面代码简化成下面格式
c1.forEach(s-> System.out.println(s));
Collection集合不支持for循环遍历,集合不能通过索引查找对象
集合中存储的是元素的地址
List集合因为支持索引,所以多了很多索引的api,其他Collection的功能也都继承。
//list集合特点 有序 重复 有索引
List<String> list=new ArrayList<>();
list.add("java");
list.add("java");
list.add("html");
list.add("spring");
//1.在某个位置插入元素
list.add(2,"ssm");
//2.根据索引删除元素,返回被删除元素
System.out.println(list.remove(1));
//3.根据索引获取元素
System.out.println(list.get(2));
//4.修改索引位置的元素,返回被修改的元素
System.out.println(list.set(2, "mybatis"));
List实现类的底层原理
ArrayList底层是基于数组实现的,查询速度快,增删慢。
LinkedList底层是基于双链表实现的,查询元素慢,增删首尾元素快。
List集合的遍历方式有四种
iterator、增强for、lambda表达式、for循环
写一下for循环就行,通过list.get(索引) 来遍历
List<String> list=new ArrayList<>();
list.add("java");
list.add("java");
list.add("html");
list.add("spring");
for (int i = 0; i < list.size(); i++) {
String s = list.get(i);
System.out.println(s);
}
ArrayList集合底层原理
List集合存储的元素超过容量后会扩容,扩容到原来的1.5倍。
一些常用api
//栈
LinkedList<String> stack=new LinkedList<>();
//压栈,入栈
stack.addFirst("第一颗子弹");
stack.push("第二颗子弹"); //用push代替addFirst,作用一样
stack.push("第三颗子弹");
System.out.println(stack);
stack.removeFirst();
stack.pop(); //用stack.pop代替removeFirst,作用一样
System.out.println(stack);
//队列
LinkedList<String> queue=new LinkedList<>();
//入队
queue.addLast("1号");
queue.addLast("2号");
queue.addLast("3号");
System.out.println(queue);
//出队
queue.removeFirst();
queue.removeFirst();
System.out.println(queue);
集合的并发修改异常问题
必须用迭代器自带的remove,如果用集合的remove方法,会报错(并发修改异常),会漏删
List<String> list = new ArrayList<>();
list.add("java");
list.add("java");
list.add("html");
list.add("ssm");
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()){
String next = iterator.next();
if ("java".equals(next)){
//list.remove("java") 会报错
iterator.remove(); //保证不后移,会遍历到全部元素
}
}
System.out.println(list);
不能用forEach遍历删除,Bug解决不了。
lambda也不能遍历删除,底层源码就是forEach
for循环正向着删除,也会漏删,但是不会报错。
List<String> list = new ArrayList<>();
list.add("html");
list.add("ssm");
list.add("java");
list.add("java");
for (int i = 0; i < list.size()-1; i++) {
if("java".equals(list.get(i))){
list.remove("java");
}
}
System.out.println(list);
会漏删
for循环倒着遍历删除,不会出错
List<String> list = new ArrayList<>();
list.add("html");
list.add("ssm");
list.add("java");
list.add("java");
//倒着遍历不会出错
for (int i = list.size()-1; i >=0; i--) {
if("java".equals(list.get(i))){
list.remove("java");
}
}
System.out.println(list);
for循环如果非要正向删除,在下面加上 i-- 就可以
List<String> list = new ArrayList<>();
list.add("html");
list.add("ssm");
list.add("java");
list.add("java");
for (int i = 0; i < list.size()-1; i++) {
if("java".equals(list.get(i))){
list.remove("java");
}
i--;
}
System.out.println(list);
泛型
任意类型 + " " 都变成字符串类型
double a= 1.0;
String s=a+"";
System.out.println(s);
泛型类、泛型接口、泛型方法
泛型方法
泛型方法用<T>修饰,定义的数组必须是引用类型。
public static void main(String[] args) {
Integer[] arr={2,4,6,3,1};
printArray(arr);
}
public static <T> void printArray(T[] arr){
if (arr !=null){
StringBuilder sb=new StringBuilder("[");
for (int i = 0; i <= arr.length - 1; i++) {
sb.append(arr[i]).append(i == arr.length - 1 ? "" : ",");
}
sb.append("]");
System.out.println(sb);
}else{
System.out.println(arr);
}
}
泛型接口
泛型接口的作用,可以让实现类选择当前功能需要操作的数据类型。
有Teacher类、Student类、Data接口、TeacherData实现类
Data接口种的代码如下
泛型通配符
?在使用泛型的时候代表一切类型。 泛型的上下限 ? extends Car 必须是Car或其子类
? super Car 必须是父类或Car
Set集合
因为根据哈希值,可以快速的实现增删改查。
先根据哈希值取余,找到位置,再看位置是否为null,如果为null直接存入。不为null,用equals()方法比较内容是否一样。
Set集合去重复原因,先判断哈希值,在判断equals。Set集合里面存对象,如果对象中内容一样,set想要去掉重复的,必须在对象类中,重写hashcode()和equals()方法。
在没有在Student类中,重写equals()和
Set<Student> set=new HashSet<>();
Student s1=new Student("伽罗",20,170.0);
Student s2=new Student("伽罗",20,170.0);
Student s3=new Student("刘备",23,180.0);
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
set.add(s1);
set.add(s2);
set.add(s3);
System.out.println(set);
输出台中,hashcode值不一样,而且集合中存储两个伽罗信息
LinkedHashSet
TreeSet
要想使用TreeSet存储自定义类型,需要指定排序规则。
在对象类实现Comparable接口,重写compareTo方法时,要注意下面规则
写一个Student类
public class Student implements Comparable<Student>{
private String name;
private int age;
private double height;
public Student(String name, int age, double height) {
this.name = name;
this.age = age;
this.height = height;
}
public Student() {
}
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 double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", height=" + height +
'}';
}
@Override
public int compareTo(Student o) {
return this.age-o.age;
}
}
在重写的方法中,return this.age - o.age; 如果有两个对象的年龄相等,会被TreeSet判定为两个相同的对象,就会去掉一个。
输出结果会这样显示
重写的方法可以这样写,就只会返回两个值
@Override
public int compareTo(Student o) {
return this.age-o.age >=0 ? 1:-1;
}
第二种自定义规则的方法,用集合自带的比较器比较。
public static void main(String[] args) {
Set<Student> set=new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getAge()-o2.getAge() >=0 ? 1:-1;
}
});
Student s1=new Student("关羽",20,170.0);
Student s2=new Student("伽罗",20,170.0);
Student s3=new Student("刘备",23,180.0);
set.add(s1);
set.add(s2);
set.add(s3);
System.out.println(set);
}
如果想通过身高去比较,用Double的api,Double.compare(o2.getHeigth(),o1.getHeight()) 这是降序
Set<Student> set=new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return Double.compare(o2.getHeight(),o1.getHeight());
}
});
用Double.compare()比较,当两个数值大小一样时,应该怎么办?
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
double[] values = { 3.5, 2.0, 5.1, 3.5, 1.8 };
Arrays.sort(values, (a, b) -> {
int compareResult = Double.compare(a, b);
if (compareResult != 0) {
return compareResult;
} else {
// 在比较结果为0时,在这里添加其他排序条件
// 例如,按照原始顺序保持相等值的相对顺序
return 0; // 或者可以返回其他值进行排序
}
});
// 输出排序结果
for (double value : values) {
System.out.println(value);
}
}
}
可变参数
public static void main(String[] args) {
MethodSum(); //可以不传入参数
MethodSum(1); //可以传1个参数
MethodSum(2,3,4,5,6); //可以传多个参数
}
//一个方法只能传入一个可变参数
//传入可变参数,必须放在其他参数后面
//public static void MethodSum(int a,int...arr)
public static void MethodSum(int...arr){
//可变参数在方法本质就是一个数组
System.out.println(arr.length);
System.out.println(Arrays.toString(arr));
}
Collections集合工具类
快捷键 Shift+F6 选中一个名字后,可以一下全部改所有的名字
Collections几个常用的api
public static<T> boolean addAll(Collection<? super T>)给集合对象批量添加元素。
addAll中添加T类和他的子类都可以。
1.批量添加数据(给所有的Collection集合添加数据)
public static void main(String[] args) {
List<Integer> list=new ArrayList<>();
list.add(2);
list.add(89);
list.add(34);
list.add(6);
Collections.addAll(list,2,3,4,5,11,6,100,0); //一行代码就搞定
}
2.打乱List集合顺序
public static void shuffle (List<?> list) :打乱list集合顺序
Collections.shuffle();
3.对List集合排序
public static<T> void sort(List<T> list);
Collections.sort(); 默认排有值特性的List,比如int类型
List<Integer> list=new ArrayList<>();
Collections.addAll(list,7,56,87,4,0,1);
Collections.sort(list);
System.out.println(list);
如果对自定义对象排序,除非有两种情况,第一种:对象类实现了Comparable接口,并重写了CompareTo方法,自定义了比较规则。
第二种:如下代码
public static void main(String[] args) {
List<People> list=new ArrayList<>();
People p1=new People("伽罗",20,false);
People p2=new People("刘备",23,true);
People p3=new People("关羽",32,true);
Collections.addAll(list,p1,p2,p3);
Collections.sort(list, new Comparator<People>() { //自定义规则
@Override
public int compare(People o1, People o2) {
return o1.getAge()-o2.getAge();
}
});
System.out.println(list);
}
斗地主案例
先定义一个Card类 (index的作用是给每个牌赋值,每张牌的真正大小)
public class Card {
private String size;
private String color;
private int index;
public Card() {
}
public Card(String size, String color,int index) {
this.size = size;
this.color = color;
this.index = index;
}
public String getSize() {
return size;
}
public void setSize(String size) {
this.size = size;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
@Override
public String toString() {
return color+size;
}
public static ArrayList<Card> allCards=new ArrayList<>();
static {
String[] size = {"2","3","4","5","6","7","8","9","10","J","Q","K","A"};
String[] color = {"♥","♣","♠","♦"};
for (String s : color) {
int index=0;
for (String s1 : size) {
++index; //每张牌都有索引值的大小
Card c=new Card(s1,s,index);
allCards.add(c);
}
}
Card da = new Card("","🐅",21);
Card xiao = new Card("","🃏",20);
//所有的牌已经存入到集合中
Collections.addAll(allCards,da,xiao); //Collections的api
}
public static void main(String[] args) {
//洗牌
Collections.shuffle(allCards);
//建立3个玩家,也就是三个集合
List<Card> wang = new ArrayList<>();
List<Card> zhang=new ArrayList<>();
List<Card> li = new ArrayList<>();
//54张牌,发51张,采用轮询方式,轮询用取余
for (int i = 0; i < allCards.size() - 3; i++) {
if (i % 3 ==0){
wang.add(allCards.get(i));
}else if (i % 3 ==1){
zhang.add(allCards.get(i));
}else if(i % 3 ==2){
li.add(allCards.get(i));
}
}
//把最后三张牌当作地主牌
List<Card> cards = allCards.subList(allCards.size() - 3, allCards.size());
sortCard(wang);
sortCard(zhang);
sortCard(li);
System.out.println(cards);
}
//定义一个方法,用来排序
private static void sortCard(List<Card> cards) {
Collections.sort(cards, new Comparator<Card>() {
@Override
public int compare(Card o1, Card o2) {
return o2.getIndex()-o1.getIndex();
}
});
System.out.println(cards);
}
Map集合
Map集合的遍历方式
第一种:键找值,先拿到集合的全部键,遍历每个键,根据键取值
Map<String,Integer> map=new HashMap<>();
map.put("伽罗",20);
map.put("刘备",23);
map.put("关羽",27);
map.put("伽罗",30);
Set<String> keySet = map.keySet();
for (String key : keySet) {
Integer value = map.get(key);
System.out.println(key+"="+value);
}
第二种:键值对
使用forEach遍历集合,发现Map集合的键值对元素直接是没有类型的。所以不可以直接forEach遍历集合。
Map<String,Integer> map=new HashMap<>();
map.put("伽罗",20);
map.put("刘备",23);
map.put("关羽",27);
map.put("伽罗",30);
//把map集合转换成set集合
Set<Map.Entry<String, Integer>> entries = map.entrySet();
for (Map.Entry<String, Integer> entry : entries) {
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key+"="+value);
}
第三种:Lambda表达式
第三种,map.forEach(new BigConsumer)
Map<String,Integer> map=new HashMap<>();
map.put("伽罗",20);
map.put("刘备",23);
map.put("关羽",27);
map.put("伽罗",30);
map.forEach(new BiConsumer<String, Integer>() {
@Override
public void accept(String s, Integer integer) {
System.out.println(s+"="+integer);
}
});
简化之后代码,简化为一行(推荐用这种,简单)
public static void main(String[] args) {
Map<String,Integer> map=new HashMap<>();
map.put("伽罗",20);
map.put("刘备",23);
map.put("关羽",27);
map.put("伽罗",30);
map.forEach(( s, integer) -> System.out.println(s+"="+integer));
}
public static void main(String[] args) {
StringBuilder sb=new StringBuilder();
String[] JingDian={"A","B","C","D"};
Random r=new Random();
//让80个人随机选择景点
for (int i = 0; i < 80; i++) {
sb.append(JingDian[r.nextInt(JingDian.length)]);
}
System.out.println(sb);
Map<Character,Integer> map=new HashMap<>();
for (int i = 0; i < sb.length(); i++) {
char c = sb.charAt(i); //获取每一个景点
//判断集合是否包含这个景点,如果有,取出值加1
if (map.containsKey(c)){
map.put(c, map.get(c)+1);
}else{
map.put(c,1);
}
}
System.out.println(map);
}
LinkedHashMap
集合嵌套
public static void main(String[] args) {
Map<String, List<String>> map= new HashMap<>();
List<String> list1=new ArrayList<>();
Collections.addAll(list1,"A","B","C");
List<String> list2=new ArrayList<>();
Collections.addAll(list2,"A","D");
List<String> list3=new ArrayList<>();
Collections.addAll(list3,"C","D");
map.put("伽罗",list1);
map.put("刘备",list2);
map.put("关羽",list3);
System.out.println(map);
//统计人数
Map<String,Integer> people=new HashMap<>();
//先得到集合map的所有的值,再遍历map
Collection<List<String>> values = map.values();
System.out.println(values);
for (List<String> value : values) {
for (String s : value) {
if (people.containsKey(s)){
people.put(s,people.get(s)+1);
}else{
people.put(s,1);
}
}
}
System.out.println(people);
}
不可变集合
如何创建不可变集合
创建不可变集合
List<Double> list=List.of(34.0,23.3,34.4,90.9);
//list.add(34.2);
//list.set(2,88.8);
// System.out.println(list);
Set<String> set=Set.of("伽罗","刘备","关羽","吕布");
// set.add("张飞");
Map<String,Integer> maps=Map.of("张飞",20,"关羽",21,"刘备",22);
//maps.put("伽罗",23);
修改删除不可变集合之后,会报java.lang.UnsupportedOperationException