List接口和Set接口单例集合
1.单例集合:将数据一个一个的进行存储。
.2双例集合:基于 Key 与 Value 的结构
2.集合中一些常用的方法
1.List接口
List 接口特点
**有序:**有序(元素存入集合的顺序和取出的顺序一致)。List 中每个元素都有索引标记。
可以根据元素的索引标记(在 List 中的位置)访问元素,从而精确控制这些元素。
**可重复:**List 允许加入重复的元素。更确切地讲,List 通常允许满足 e1.equals(e2) 的
元素重复加入容器。
List 的常用方法
1.1 ArrayList容器类
List<String> list = new ArrayList<>(); //定义方法
1.1.1添加元素和获取元素
list.add(Object) // 有顺序的添加元素 有返回值true|false 执行后list的内容会发生改变
list.get(i) // 获取元素 返回索引i对应的元素 执行后list的内容不会发生改变
测试代码
import java.util.ArrayList;
import java.util.List;
// list.add()添加元素 有返回值true|false list.get(i) 获取元素
public class AppTest{
public static void main(String[] args) {
List<String> list = new ArrayList<>();
// list.add() 有顺序的添加元素 有返回值
boolean flag = list.add("jordan");
list.add("kobe");
list.add("james");
System.out.println(flag);
// list.get(i) 获取元素, 得到对应索引i的元素
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
运行结果:
1.1.2删除元素
方法1:根据索引位置i删除元素 返回值为删除的元素 执行后list的内容会发生改变
list.remove(i) //根据索引位置i删除元素 返回值为删除的元素 执行后list的内容会发生改变
测试代码
import java.util.ArrayList;
import java.util.List;
// list.remove(i) 根据索引位置删除元素
public class AppTest{
public static void main(String[] args) {
List<String> list = new ArrayList<>();
// list.add() 有顺序的添加元素 有返回值true|false
list.add("jordan");
list.add("kobe");
list.add("james");
System.out.println(list.toString()); // 利用list.toString()打印列表
// list.remove(i) //根据索引位置删除元素 返回值为被删除的元素
String value = list.remove(1);
System.out.println(value);
System.out.println(list.toString()); // 利用list.toString()打印列表
}
}
运行结果
方法2:
list.remove(Object)// 删除指定列表元素 返回值为true|false 执行后list的内容会发生改变
import java.util.ArrayList;
import java.util.List;
// list.remove() 删除指定列表元素
public class List02 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
// list.add() 有顺序的添加元素 有返回值true|false
list.add("jordan");
list.add("kobe");
list.add("james");
System.out.println(list.toString()); // 利用list.toString()打印列表
// list.remove(Object) 删除指定列表元素 有返回值true|false
boolean flag3 = list.remove("jordan");
System.out.println(flag3);
System.out.println(list.toString()); // 利用list.toString()打印列表
}
}
运行结果:
1.1.3替换元素
list.set(i, Object) // i是索引,返回值值为被替换掉的元素 执行后list的内容会发生改变
测试代码
// list.set(i, Object)替换元素
public class List03 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
// list.add() 有顺序的添加元素 有返回值
list.add("jordan");
list.add("kobe");
list.add("james");
System.out.println(list.toString()); // 利用list.toString()打印列表
String val = list.set(0, "curry"); // list.set()替换元素 返回值值为被替换掉的元素jordan
System.out.println(val);
System.out.println(list.toString()); // 利用list.toString()打印列表
}
}
运行结果:
1.1.4清空列表
list.clear(); //判断列表是否为空 list.isEmpty() 返回true|false 执行后list的内容不会发生改变
测试代码
import java.util.ArrayList;
import java.util.List;
public class List04 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("jordan");
list.add("kobe");
list.add("james");
System.out.println(list.toString());
list.clear(); //清空list列表
System.out.println(list.size());
boolean flag = list.isEmpty(); // 判断列表是否为空 返回true|false
System.out.println(flag);
}
}
运行结果:
1.1.5判断容器中是否包含指定元素 返回true|false
list.contains(Object) # 判断容器中是否包含指定元素 返回true|false 执行后list的内容不会发生改变
//list.contains() // 判断容器中是否包含指定元素 返回true|false 执行后list的内容不会发生改变
public class List06 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("jordan");
list.add("kobe");
list.add("james");
list.add("jordan");
System.out.println(list.toString());
boolean flag1 = list.contains("jordan");
System.out.println(flag1);
boolean flag2 = list.contains("dwade");
System.out.println(flag2);
}
}
运行结果:
1.1.6查找元素出现的位置
list.indexOf(Object) //查找元素第一次出现的位置 返回值是一个索引 执行后list的内容不会发生改变
list.lastIndexOf(Object) //查找元素最后一次出现的位置 返回值是一个索引 执行后list的内容不会发生改变
测试代码
//查找元素的位置
public class List07 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("jordan");
list.add("kobe");
list.add("james");
list.add("jordan");
System.out.println(list.toString());
int index = list.indexOf("jordan"); //第一次出现的位置
System.out.println(index);
int lastIndex = list.lastIndexOf("jordan"); // 最后一次出现的位置
System.out.println(lastIndex);
}
}
运行结果
1.2Vector容器实现类
List<String> v = new Vector<>(); //定义方法 其他的方法和ArrayList方法类似
测试代码:
import java.util.List;
import java.util.Vector;
public class Vector01 {
public static void main(String[] args) {
//实例化 Vector
List<String> v = new Vector<>();
v.add("a");
v.add("b");
v.add("a");
//方式1 遍历
for(int i=0;i<v.size();i++){
System.out.println(v.get(i));
}
System.out.println("----------------------");
//方式2 遍历
for(String str:v){
System.out.println(str);
}
System.out.println("----------------------");
//方式3 遍历
System.out.println(v.toString());
}
}
运行结果:
1.3Stack 容器(栈)
Stack 栈容器,是 Vector 的一个子类,它实现了一个标准的后进先出(LIFO:Last In Frist Out)
的栈。
1.3.1Stack的定义以及常用方法:
Stack<String> stack = new Stack<>(); // 定义栈
stack.push("a"); //元素a入栈
String p1 = stack.pop(); //出栈
stack.empty(); //判断栈容器是否为空
stack.peek(); //查看栈顶元素
stack.search("c"); //返回元素c在栈容器中的位置
测试代码
import java.util.Stack;
public class Stack01 {
public static void main(String[] args) {
//实例化栈容器
Stack<String> stack = new Stack<>();
//将元素添加到栈容器中
stack.push("a");
stack.push("b");
stack.push("c");
//判断栈容器是否为空
System.out.println(stack.empty());
//查看栈顶元素
System.out.println(stack.peek());
//返回元素在栈容器中的位置
System.out.println(stack.search("c"));
//获取栈容器中的元素
String p1 = stack.pop();
System.out.println(p1);
String p2 = stack.pop();
System.out.println(p2);
String p3 = stack.pop();
System.out.println(p3);
}
}
运行结果:
1.3.2stack使用案例: 利用站判断符号的对称性, 测试算术表达式括号是否正确
import java.util.Stack;
//匹配符号的对称性
public class Stack02 {
public static void main(String[] args) {
String str="...{.....[....(....)...]....}..(....)..[...].(.)."; // 等待测试的算术表达式
//实例化 Stack
Stack<String> stack = new Stack<>();
//假设修正法
boolean flag = true;//假设是匹配的
//拆分字符串获取字符
for(int i=0;i<str.length();i++){
char c = str.charAt(i);
if(c == '{'){
stack.push("}");
}
if(c == '['){
stack.push("]");
}
if(c == '('){
stack.push(")");
}
//判断符号是否匹配
if(c == '}' || c == ']' || c == ')'){
if(stack.empty()){
//修正处理
flag = false;
break;
}
String x = stack.pop();
if(x.charAt(0) != c){ // 因为x是String类型而c是字符类型所以要进行转化
//修正处理
flag = false;
break;
}
}
}
if(!stack.empty()){
//修正处理
flag = false;
}
System.out.println(flag);
}
}
运行结果
1.4LinkedList 容器类
1.4.1 公共方法使用(List中的方法)
LinkedList 实现了 List 接口,所以 LinkedList 是具备 List 的存储特征的(有序,元素有重复)。
List<String> list = new LinkedList<>(); // 定义
测试代码
import java.util.LinkedList;
import java.util.List;
public class LinkedListTest {
public static void main(String[] args) {
List<String> list = new LinkedList<>();
//添加元素
list.add("a");
list.add("b");
list.add("c");
list.add("a");
//获取元素
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
System.out.println("-------------------");
for(String str :list){
System.out.println(str);
}
}
}
运行结果
1.4.2 非公共方法使用
测试代码:
import java.util.LinkedList;
public class LinkedList02 {
public static void main(String[] args) {
System.out.println("-------LinkedList-------------");
LinkedList<String> linkedList1 = new LinkedList<>();
linkedList1.addFirst("a"); // 头插入
linkedList1.addFirst("b");
linkedList1.addFirst("c");
for (String str:linkedList1){
System.out.println(str);
}
System.out.println("----------------------");
LinkedList<String> linkedList = new LinkedList<>();
linkedList.addLast("a"); // 尾插入
linkedList.addLast("b");
linkedList.addLast("c");
for (String str:linkedList){
System.out.println(str);
}
System.out.println("---------------------------");
System.out.println(linkedList.getFirst()); //得到头节点
System.out.println(linkedList.getLast()); //得到尾节点
System.out.println("-----------------------");
linkedList.removeFirst(); // 出链表 移除头节点
linkedList.removeLast(); // 出链表 移除尾节点
for (String str:linkedList){
System.out.println(str);
}
System.out.println("-----------------------");
linkedList.addLast("c");
linkedList.pop(); //linkedList.removeFirst(); 出链表 移除头节点
for (String str:linkedList){
System.out.println(str);
}
System.out.println("-------------------");
linkedList.push("h"); // linkedList1.addFirst("h"); 插入头节点
for (String str:linkedList){
System.out.println(str);
}
System.out.println(linkedList.isEmpty());
}
}
运行结果
1.5将单例集合转换成数组
Object[] arr = list.toArray(); list.toArray() //方式1 返回值为Object数组, list本身不会改变
String[] arr2 = list.toArray(new String[list.size()]); // 方式2 转化为指定的String泛型数组 list本身不会改变
测试代码
import java.util.ArrayList;
import java.util.List;
//将单例集合转换成数组
public class List08 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("jordan");
list.add("kobe");
list.add("james");
System.out.println(list.toString());
Object[] arr = list.toArray();
for(int i=0;i<arr.length;i++){
String str = (String)arr[i]; // 进行强制类型转化
System.out.print(str+ "\t");
}
System.out.println();
//可以将单例集合转换为指定类型数组。
//但是。类型需要参考泛型中的类型。
String[] arr2 = list.toArray(new String[list.size()]); // 转化为指定的String数组
for(int i=0;i<arr2.length;i++){
System.out.print(arr2[i]+ "\t");
}
}
}
运行结果
1.6容器的并集操作
a.addAll(b); //将集合b添加到a中 返回值为true|false 执行完之后a会发生改变, b不会
测试代码:
import java.util.ArrayList;
import java.util.List;
//容器的并集操作 a.addAll(b), 将b添加到a中
public class List09 {
public static void main(String[] args) {
List<String> a = new ArrayList<>();
a.add("a");
a.add("b");
a.add("c");
System.out.println(a.toString());
List<String> b = new ArrayList<>();
b.add("b");
b.add("c");
b.add("d");
System.out.println(b.toString());
//a 并 b
boolean flag6 = a.addAll(b); //将b添加到a中
System.out.println(flag6);
System.out.println(a.toString());
}
}
运行结果
1.7容器的交集操作
a1.retainAll(b1) // 容器的交集操作 返回值为true|false a1会改变 b1不会
测试代码
//容器的交集操作
public class List10 {
public static void main(String[] args) {
List<String> a1 = new ArrayList<>();
a1.add("a");
a1.add("b");
a1.add("c");
System.out.println(a1.toString());
List<String> b1 = new ArrayList<>();
b1.add("b");
b1.add("c");
b1.add("d");
System.out.println(b1.toString());
// a1会改变
boolean flag2 = a1.retainAll(b1);// 容器的交集操作 返回值为true|false
System.out.println(flag2);
System.out.println(a1);
}
}
运行结果
1.8容器的差集操作
a2.removeAll(b2); // 返回值为true|false 执行之后a2会发生改变 b2不会发生改变
测试代码
import java.util.ArrayList;
import java.util.List;
public class List11 {
public static void main(String[] args) {
List<String> a2 = new ArrayList<>();
a2.add("a");
a2.add("b");
a2.add("c");
System.out.println(a2.toString());
List<String> b2 = new ArrayList<>();
b2.add("b");
b2.add("c");
b2.add("d");
System.out.println(b2.toString());
boolean flag = a2.removeAll(b2); // 在集合a2去除b2中含有的元素
System.out.println(flag);
System.out.println(a2.toString());
}
}
运行结果
集合详细笔记:https://pan.baidu.com/s/1hSg1HY1AjOLFCi3gY-go0Q
提取码:2022