第十七章集合上（接口和实现类）

最新推荐文章于 2022-05-20 21:45:26 发布

Burn_

最新推荐文章于 2022-05-20 21:45:26 发布

阅读量482

点赞数

分类专栏： JavaSE

本文链接：https://blog.csdn.net/Burn_/article/details/95732808

版权

JavaSE 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

javase笔记

一、集合
二、线性表的底层技术
三、Collections

一、集合

容器

1.变量
2.数组的特点：

空间是连续的（一个空间挨着一个空间）；
长度固定；
可以存储基本数据类型和引用数据类型；

3.集合的特点：

存储引用数据类型；
容量可变长（自动的扩容）；

在这里插入图片描述

集合是一些接口，一些实现类。

1.Collection（单例存储）

Collection接口： 它是一个（集合）父接口，可以存储重复的数据，本身没有顺序（具有通用的一些功能）；

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
public class TestCollection {
	public static void main(String[] args) {
		/**		Collection接口： (导包：import java.util.Collection;;)
		 * 		ArrayList实现类：(导包：import java.util.ArrayList;)
		 * 		Collection接口：不能直接创建对象，可以引用实现类对象（多态）
		 * 		集合只能用泛型去约束容器存储的内容
		 */
//创建Collection集合:c
		Collection<String> c = new ArrayList<>();//实现类独特的功能不能使用;
		//向集合容器添加元素 ，添加成功true
		c.add("aa");
		c.add("bb");
		c.add("cc");
		System.out.println(c);//[aa, bb, cc]
//1.查看集合是否为空（空是true）
		System.out.println(c.isEmpty());//false
//2.返回集合中元素的个数
		System.out.println(c.size());//3
		//新的集合:c1
		Collection<String> c1 = new ArrayList<>();
		c1.add("dd");
		c1.add("ee");
		c1.add("ff");
		System.out.println(c1);//[dd, ee, ff]
//3.把参数集合中的所有元素 添加到当前集合c中 只要当前集合发生了改变返回true
		c.addAll(c1);
		System.out.println(c);//[aa, bb, cc, dd, ee, ff]
//4.把参数元素（对象）从当前集合中移除  只要当前集合发生了改变返回true
		c.remove("cc");
		System.out.println(c);//[aa, bb, dd, ee, ff]
//5.把参数集合中的所有元素 从当前集合c中移除掉
		//c.removeAll(c1);
		//System.out.println(c);//[aa, bb]
//6.把不在参数集合中的所有元素，从当前集合中移除掉
		c.retainAll(c1);
		System.out.println(c);//[dd, ee, ff]
//7.参数对象在当前集合中是否包含
		System.out.println(c.contains("ee"));//true
//8.参数集合的所有元素在当前集合中是否包含
		System.out.println(c.containsAll(c1));//true
//9.集合转数组
		Object [] o = c.toArray();//将集合转换成了Object类型的数组
		o = c.toArray(new Object [0]);//将集合中的元素存在数组里
		//保留类型
		String [] str = c.toArray(new String[0]);
		/* stream：
		 * forEach：输出
		 * System.out::printlnforEach：Lambda表达式
		 */
		Arrays.stream(o).forEach(System.out::println);//将Object数组中的元素输出
//10.清空集合
		c.clear();
		System.out.println(c.size());//0
		System.out.println(c.isEmpty());//true
	}
}

2.List线性表

List: 线性表（具有独特的一些方法），可以存储重复的数据，有顺序（线性排列的）；

import java.util.ArrayList;
import java.util.List;
public class TestList {
	public static void main(String[] args) {
		/**		List接口：      (导包：import java.util.List;)
		 * 		ArrayList实现类：(导包：import java.util.ArrayList;)
		 * 		List接口：它是Collection的子接口（具备自己特有的功能）
		 * 		List：线性表。线性表是一种数据结构
		 * 		数据结构（数据之间的关系，数据的组织形式）
		 * 		线性表：一个由很多相同特性的元素组成的，有序的序列
		 * 			     一个元素连接下一个元素
		 * 		List:有位置，有索引
		 */
//List方法
	//创建List集合：list
		List<String> list = new ArrayList<>();
		list.add("aa");//位置索引0
		list.add("bb");//位置索引1
		list.add("cc");//位置索引2
//1.把一个元素添加到指定的索引位置  add(index,element)
		list.add(1, "hello");
		System.out.println(list);//[aa, hello, bb, cc]
//2.获得参数索引位置的元素
		System.out.println(list.get(1));//hello
//3.把指定索引位置的元素改为指定元素
		list.set(1, "tom");
		System.out.println(list);//[aa, tom, bb, cc]
		//--------------
		list.add("cc");
		list.add("cc");
		System.out.println(list);//[aa, tom, bb, cc, cc, cc]
//4.获得参数元素在集合中第一次出现的位置索引
		System.out.println(list.indexOf("cc"));//3
//5.获得参数元素在集合中最后一次出现的位置索引
		System.out.println(list.lastIndexOf("cc"));//5
//6.取子集【起始位置，终止位置）
		System.out.println(list.subList(1, 3));
//7.集合排序
		//升序
		//null 意思是没有指定Comparator,会按照Comparable自然排序
		list.sort(null);
		System.out.println(list);//[aa, bb, cc, cc, cc, tom](阿斯克码值)
		//降序(自己定义顺序)
		list.sort((s1,s2)->{return s2.compareTo(s1);});
		System.out.println(list);//[tom, cc, cc, cc, bb, aa]
	}
}

3.集合遍历

3.1 Iterator迭代器

作用： 遍历集合中的各种容器
Iterator迭代器：通常用来遍历Collection接口，子接口，和实现类的
Collection集合的遍历方式

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class TestCollection_Iterator {
	public static void main(String[] args) {
		/**		最通用的：Collection集合的遍历方式
		 * 		不同的集合遍历的方式不一样
		 * 		Iterator是一个<泛型>接口
		 * 		Iterator迭代器:就是对集合中的元素进行迭代的，进行遍历的，进行循环的
		 * 		适合Collection集合的遍历
		 */
 //创建Collection集合：c
		Collection<String> c = new ArrayList<>();
		c.add("aa");
		c.add("bb");
		c.add("cc");
		//不叫遍历，只是输出了集合元素的名称，它会自动调用toString方法，然后重写了toString，所展示的信息
		System.out.println(c);//[aa, bb, cc]
//遍历数组元素 (Collection没有顺序，没有分配索引)--------------
	//1.循环增强for是用来遍历集合和数组的 
		for (String s:c) {
			System.out.println(s);
		}
	//2.这里的forEach属于集合对象Collection的方法（是最简单的方式）
		c.forEach(System.out::println);
	//3.这里的forEach属于sream流接口的方法
		c.stream().forEach(System.out::println);
		System.out.println("-----------------------");
	//4.Iterator迭代器
		//获得了一个迭代器对象（i作为迭代器）
		//创建了迭代器之后，迭代器的指针在第一个元素前面
		Iterator<String> i = c.iterator();//不同的集合对象可以调用iterator();方法来去获得一个迭代器对象
		//System.out.println(i.next());//aa 获得迭代器指针后面的下一个元素（迭代器指针在第一个元素后面，第二个元素前面）
		//System.out.println(i.next());//bb
		//i.remove();//删除最近一次next访问的元素
		//System.out.println(c);//[aa, cc]
		while (i.hasNext()) {//i.hasNext()集合中是否存在下一个元素
			System.out.println(i.next());
		}
	//5.Iterator迭代器的forEachRemaining方法遍历
		Iterator<String> i1 = c.iterator();//新建了一个迭代器指针i1
		i1.forEachRemaining(System.out::println);
	}
}

List集合的遍历方式

3.2 ListIterator子迭代器

ListIterator迭代器：专门遍历List集合的
List集合的遍历方式

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class TestList_Iterator {
	public static void main(String[] args) {
		//创建List集合
		List<String> list = new ArrayList<>();
		list.add("aa");
		list.add("bb");
		list.add("cc");
		//List遍历(有顺序，有位置，有索引)---------------------
		//1.普通for
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
		//2.ListIterator迭代器（只针对List集合）
		//向下迭代，并且添加元素
		//获得ListIterator的一个对象
		System.out.println("--------------");
		ListIterator<String> i1 = list.listIterator();
		while (i1.hasNext()) {
			System.out.println(i1.next());
			i1.add("hello");
		}
		//向上迭代
		while (i1.hasPrevious()) {
			System.out.println(i1.previous());
		}
	}
}

二、线性表的底层技术

1. 数组:

ArrayList： 线程非安全的，性能好。（扩容：1.5倍扩容）
Vector： 线程安全的，性能低。（扩容：2倍扩容）现在已经被淘汰了

2. 链表:

LinkedList： 一些非连续的节点，组成的存储结构

分类
       单向链表：(节点只有一个链域的)
                单项非循环：【节点：1个值域(存数据)|一个链域(存地址)】
                单项    循环：
在这里插入图片描述
       双向链表：(节点有两个链域的)
                双项非循环：
                双项    循环：

3. 数组和链表的差别:

ArrayList 和 LinkedList 的区别：
ArrayList：遍历或随机访问，效率高。
LinkedList：遍历或随机访问，效率低。
ArrayList：插入元素或删除元素，效率低。
LinkedList：插入元素或删除元素，效率高。

三、Collections

Collections：集合工具类

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class TestCollections {
	public static void main(String[] args) {
		//创建List集合：list
		List<Integer> list = new ArrayList<>();
		//向集合中添加多个元素:Collection
		Collections.addAll(list, 22,11,33);
		System.out.println(list);//[22, 11, 33]
		//1.自然升序排序Comparble
		Collections.sort(list);
		System.out.println(list);//[11, 22, 33]
		//2.自定义排序，针对List,Comparator
		//Collections.sort(list, (n1,n2)->{return n2-n1;});
		//System.out.println(list);//[33, 22, 11]
		//3.二分查找法（前提：生序排序）
		System.out.println(Collections.binarySearch(list, 22));//1(规则和数组一样)
		//4.返回集合中的 最大元素Collection
		System.out.println(Collections.max(list));//33
		//5.返回集合中的 最小元素Collection
		System.out.println(Collections.min(list));//11
		//6.反转集合中的元素
		Collections.reverse(list);
		System.out.println(list);//[33, 22, 11]
		//7.返回某一个元素在集合中出现的次数
		System.out.println(Collections.frequency(list, 33));//1次
		list.add(33);
		list.add(33);
		System.out.println(list);//[33, 22, 11, 33, 33]
		System.out.println(Collections.frequency(list, 33));//3次
		//8.用第二个参数替换掉集合中的所有元素
		Collections.fill(list, 999);
		System.out.println(list);//[999, 999, 999, 999, 999]
	}
}