List接口Collection集合(一)

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|falselist.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|falselist.add("jordan");list.add("kobe");list.add("james");System.out.println(list.toString()); // 利用list.toString()打印列表// list.remove(Object) 删除指定列表元素 有返回值true|falseboolean 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()替换元素 返回值值为被替换掉的元素jordanSystem.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|falseSystem.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) {//实例化 VectorList<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="...{.....[....(....)...]....}..(....)..[...].(.)."; // 等待测试的算术表达式//实例化 StackStack<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 并 bboolean 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|falseSystem.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