java集合笔记二 —— List集合（概念方法，list集合去重，模拟栈结构）

List(接口)

该接口的父类接口有

ArrayList
底层数据结构是数组，查询快，增删慢
线程不安全，效率高
Vector（基本不用）
底层数据结构是数组，查询快，增删慢
线程安全的，效率低
linkedList
底层数据结构是链表，查询慢，增删快
线程不安全，效率高

List接口下面有很多个子类实现，如果你不知道使用谁，也没有什么特殊的要求，就可以直接选择使用ArrayList

- - - list的相关方法
    - Arrays.asList
    - 遍历List集合
    - linkedList类概述
  - list的相关操作
  - - list集合去重
    - - 方式一、利用一个新集合去重
        方式二、在原集合上操作
    - 用linkedList 模拟栈结构

list的相关方法

下面以ArrayList举例

在末尾添加一个元素 add(E e)
返回集合中的元素个数 size()

import java.util.ArrayList;
import java.util.List;
public class ListDemo1 {
    public static void main(String[] args) {
        List 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 list = new ArrayList<>();
        list.add("apple"); 
        list.add("pear"); 
        list.add(1,"Banana");//在指定的位置插入
        list.add(null);  //允许添加null
        for(int i=0;i 
结果为
  
获取指定索引的元素 get(int index) 
import java.util.*;
public class ListDemo3 {
    public static void main(String[] args) {
        List 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 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 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 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 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 list2 =  Arrays.asList(i);
        for(Integer ii:list2){
            System.out.println(ii);
        }
        System.out.println("============");

	//直接像这样把值写进括号里面也可以
        List 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 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 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 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);
    }

}

 
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 
 
这里的思路是不创建一个新的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());

    }
}

java集合笔记二 —— List集合（概念方法，list集合去重，模拟栈结构）

Java相关栏目本月热门文章