List(接口)
该接口的父类接口有
- ArrayList
底层数据结构是数组，查询快，增删慢
线程不安全，效率高 - Vector（基本不用）
底层数据结构是数组，查询快，增删慢
线程安全的，效率低 - LinkedList
底层数据结构是链表，查询慢，增删快
线程不安全，效率高
List接口下面有很多个子类实现，如果你不知道使用谁，也没有什么特殊的要求，就可以直接选择使用ArrayList
目录
list的相关方法
下面以ArrayList举例
- 在末尾添加一个元素 add(E e)
返回集合中的元素个数 size()
import java.util.ArrayList;
import java.util.List;
public class ListDemo1 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("apple"); //size=1
list.add("pear"); //size=2
list.add("apple"); //size=3,允许添加重复元素
System.out.println(list.size()); //3
}
}
- 在指定索引添加一个元素 add(int index, E e)
import java.util.ArrayList;
import java.util.List;
public class ListDemo1 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("apple");
list.add("pear");
list.add(1,"Banana");//在指定的位置插入
list.add(null); //允许添加null
for(int i=0;i<list.size();i++){
String s = list.get(i);
System.out.println(s);
}
}
}
结果为
- 获取指定索引的元素 get(int index)
import java.util.*;
public class ListDemo3 {
public static void main(String[] args) {
List<String> fruits = new ArrayList<>();
fruits.add("apple");
fruits.add("banana");
fruits.add("grape");
System.out.println(fruits.get(0)); //apple
System.out.println(fruits.get(1)); //banana
}
}
- set(int index，Object obj)：把指定索引位置的元素修改为指定的值，返回修改前的值
import java.util.ArrayList;
import java.util.List;
public class demo10 {
public static void main(String[] args) {
List<String> fruits = new ArrayList<>();
fruits.add("apple");
fruits.add("banana");
fruits.add("grape");
System.out.println(fruits.set(1,"pear")); //banana
System.out.println(fruits.get(1)); //pear
}
}
- 判断该元素集合中是否存在
import java.util.ArrayList;
import java.util.List;
public class demo10 {
public static void main(String[] args) {
List<String> fruits = new ArrayList<>();
fruits.add("apple");
fruits.add("banana");
fruits.add("grape");
System.out.println(fruits.contains("pear")); //false
System.out.println(fruits.contains("apple")); //true
}
}
- 删除指定位置的元素
package review.ListDemo1;
import java.util.ArrayList;
import java.util.List;
public class demo10 {
public static void main(String[] args) {
List<String> fruits = new ArrayList<>();
fruits.add("apple");
fruits.add("banana");
fruits.add(2,"pear");
for(String s : fruits){
System.out.println(s);
}
System.out.println();
fruits.remove(2);
for(String s : fruits){
System.out.println(s);
}
}
}
结果为
Arrays.asList
Arrays.asList的作用是将数组转化为list，一般用于List集合的初始化，简化代码
- 该方法不适用于基本数据类型（比如int，double等）
- Arrays.asList生成的List集合不支持add()，remove()，clear()等方法，即Arrays.asList生成的List集合长度不可改变
- Arrays.asList会将数组与List集合链接起来，更新数组或者集合时，另一个也会随之更新
import java.util.Arrays;
import java.util.List;
public class test1 {
public static void main(String[] args) {
//往List集合中添加类的对象
List list = Arrays.asList(
new Student("zhang",12),
new Student("zhao",15)
);
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
System.out.println("---"+list.size());
System.out.println("============");
//将String数组中的值放入List集合
String[] s = {"a","b","c"};
List<String> list1 = Arrays.asList(s);
for(String ss:list1){
System.out.println(ss);
}
System.out.println("---"+list1.size());
System.out.println("============");
//将Integer数组中的值放入List集合
Integer[] i = {1,2,3};
List<Integer> list2 = Arrays.asList(i);
for(Integer ii:list2){
System.out.println(ii);
}
System.out.println("============");
//直接像这样把值写进括号里面也可以
List<String> list3 = Arrays.asList("a","b","c");
System.out.println(list3.toString());
}
}
import java.util.Arrays;
import java.util.List;
public class test2 {
public static void main(String[] args) {
//数组与List集合链接起来，更新任何一个，另一个都会随之改变
String[] s = {"a","b","c","d"};
List<String> list = Arrays.asList(s);
System.out.println(list.toString());
System.out.println("==============");
//更改List集合
list.set(0,"e");
//分别打印list集合和数组s
System.out.println(list.toString());
System.out.println(Arrays.toString(s));
System.out.println("==============");
//更改数组
s[1] = "f";
//分别打印list集合和数组s
System.out.println(list.toString());
System.out.println(Arrays.toString(s));
}
}
结果为
遍历List集合
package review.ListDemo1;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
public class test3 {
public static void main(String[] args) {
List<String> list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
//遍历List集合
// 方式一、增强for循环
for(String ss : list){
System.out.println(ss);
}
//方式二、get方法与size方法相结合
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
//方式三、iterator迭代器遍历
Iterator<String> it = list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
LinkedList类概述
底层数据结构是链表，查询慢，增删快
线程不安全，效率高
LinkedList的特有功能：
- 添加功能：
public void addFirst(Object obj):在该集合开头插入指定的元素
public void addLast(Object obj)将指定的元素追加到此列表的末尾。// 这个方法相当于add(Object) 。 - 获取功能：
public Object getFirst():返回此集合中的第一个元素。
getLast()：返回此列表中的最后一个元素。 - 删除功能：
public Object removeFirst()：移除集合中第一个元素
public Object removeLast()：移除集合中最后一个元素
import java.util.LinkedList;
public class demo10 {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
//add()添加元素
linkedList.add("hadoop");
linkedList.add("hive");
linkedList.add("flink");
System.out.println(linkedList.toString()); //[hadoop, hive, flink]
//addFirst(Object obj) 在该集合开头插入指定的元素
linkedList.addFirst("apple");
System.out.println(linkedList.toString()); //[apple, hadoop, hive, flink]
//addLast(Object obj)将指定的元素追加到此列表的末尾
linkedList.addLast("pear");
System.out.println(linkedList.toString()); //[apple, hadoop, hive, flink, pear]
//getFirst() 返回此集合中的第一个元素
System.out.println(linkedList.getFirst()); //apple
//getLast() 返回此列表中的最后一个元素
System.out.println(linkedList.getLast()); //pear
//removeFirst() 移除集合中第一个元素,返回被删除的元素
System.out.println(linkedList.removeFirst()); //apple
System.out.println(linkedList.toString()); //[hadoop, hive, flink, pear]
//removeLast() 移除集合中最后一个元素,返回被删除的元素
System.out.println(linkedList.removeLast()); //pear
System.out.println(linkedList.toString()); //[hadoop, hive, flink]
}
}
list的相关操作
list集合去重
方式一、利用一个新集合去重
package review.ListDemo1;
import java.util.ArrayList;
import java.util.List;
public class demo7 {
public static void main(String[] args) {
List list1 = new ArrayList();
list1.add("hadoop");
list1.add("hive");
list1.add("spark");
list1.add("hadoop");
list1.add("hadoop");
List list2 = new ArrayList();
for(int i=0;i< list1.size();i++){
if(!list2.contains(list1.get(i))){
list2.add(list1.get(i));
}
}
System.out.println(list2.toString());
}
}
这里的思路是写一个新的list2集合，然后for循环遍历list1，如果list2中没有包含list1的这个元素list1.get(i)，则将这个元素加入到list1中。如果list2集合中包含这个元素，则不加入。
方式二、在原集合上操作
package review.ListDemo1;
import java.util.Objects;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
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;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public void printD(){
System.out.println("test");
}
public String toStringTest(){
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
}
下面是因为String已经重写了equals方法，可以直接用，如果是自己定义的类记得像上面这样重写equals方法
package review.ListDemo1;
import java.util.ArrayList;
import java.util.List;
public class demo9 {
public static void main(String[] args) {
List list1 = new ArrayList();
list1.add("hadoop");
list1.add("hive");
list1.add("spark");
list1.add("hadoop");
list1.add("hadoop");
System.out.println(list1.toString());
for(int i=0;i<list1.size();i++){
for(int j=i+1;j<list1.size();j++){
if(list1.get(i).equals(list1.get(j))){
list1.remove(j);
j--;
}
}
}
System.out.println(list1.toString());
}
}
这里的思路是不创建一个新的list集合，就单纯的通过list集合本身的双重for循环遍历。将集合中的每一个对象与后面的其余对象进行对比，如果重复则删去。
第一重for循环是选择一个对象。第二重for循环将此对象与后面剩余的集合元素进行对比。
如果两个对象里面的属性值都相同，则删去后面重复的对象。
这里需要注意的是，要在Student类中重写equals方法，否则equals方法默认的是比较地址值，重写后改为对比属性值。
还有一点需要注意，这里删去元素后需要 j - -
因为假如删去list集合中序号为3的元素，则原先序号为4的元素就会向前补位，变成序号3
因此，如果没有 j - - 语句，就会导致跳过一个元素没有检测是否重复。
用LinkedList 模拟栈结构
import java.util.LinkedList;
public class MyStack {
LinkedList linkedList;
public MyStack(){
linkedList = new LinkedList();
}
public void addStack(Object o){
linkedList.addFirst(o);
}
public Object getStack(){
return linkedList.removeFirst();
}
public boolean StackEmpty(){
return linkedList.isEmpty();
}
}
package review.ListDemo1;
public class demo11 {
public static void main(String[] args) {
MyStack myStack = new MyStack();
myStack.addStack("hadoop");
myStack.addStack("hive");
myStack.addStack("java");
System.out.println(myStack.getStack());
System.out.println(myStack.getStack());
System.out.println(myStack.getStack());
}
}
list 排序
利用Collection.sort对list集合进行排序
方式一： Collections.sort(list, new Comparator<>() {})
利用 Comparator接口
package Demo.test;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class CollectionsSortDemo1 {
public static void main(String[] args) {
student s1 = new student("zhang", 15);
student s2 = new student("chen", 16);
student s3 = new student("wang", 14);
List<student> list = Arrays.asList(s1,s2,s3);
for (student student : list) {
System.out.println(student.getName()+"---"+student.getAge());
}
System.out.println("-----------------");
Collections.sort(list, new Comparator<student>() {
public int compare(student o1, student o2) {
return o1.getAge() - o2.getAge();
}
});
for (student student : list) {
System.out.println(student.getName()+"---"+student.getAge());
}
}
}
方式二，Collections.sort(list);
在类里面实现Compare接口，public class student1 implements Comparable<>{}
package Demo.test;
public class student1 implements Comparable<student1>{
private String name;
private int age;
public student1() {
}
public student1(String name, int age) {
this.name = name;
this.age = age;
}
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 int compareTo(student1 o) {
return o.getAge() - this.getAge();
}
}
package Demo.test;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class CollectionsSortDemo2 {
public static void main(String[] args) {
student1 s1 = new student1("zhang", 15);
student1 s2 = new student1("chen", 16);
student1 s3 = new student1("wang", 14);
List<student1> list = Arrays.asList(s1,s2,s3);
for (student1 student : list) {
System.out.println(student.getName()+"---"+student.getAge());
}
System.out.println("------------");
Collections.sort(list);
for (student1 student : list) {
System.out.println(student.getName()+"---"+student.getAge());
}
}
}
扫一扫
640
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
