List子接口 Arraylist【重点】 | 将两个集合合并成一个集合

*List子接口*

特点：有序、有下标、元素可重复

List实现类

Arraylist【重点】

  数组结构实现，查询快、增删慢。

  Jdk1.2版本，运行效率快、线程不安全。

Vector:

  数组结构实现，查询快、增删慢；

​  Jdk1.0版本，运行效率慢、线程安全

LinkedList:

  链表结构实现，增删快，查询慢。

*Arraylist【重点】*

小案例

package com.practise;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/**
 * list子接口的使用
 * 特点：有序 有下标 可以重复
 */
public class Demo03 {
    public static void main(String[] args) {
        //创建集合
        List arrayList = new ArrayList();
//         * 1.添加元素
        arrayList.add("apple");
        arrayList.add("bananer");
        arrayList.add(0,"Durian");//表示榴莲
        System.out.println("集合大小===="+arrayList.size());
        System.out.println("集合遍历===="+arrayList);//默认重写的toString方法
        //2.删除元素
//        arrayList.remove("apple");//这种方法是能删除集合中的元素的
//        System.out.println("集合大小===="+arrayList.size());
//        System.out.println("集合遍历===="+arrayList);//默认重写的toString方法
//        //通过下标进行删除
//        arrayList.remove(0);
//        System.out.println("集合大小===="+arrayList.size());
//        System.out.println("集合遍历===="+arrayList);//默认重写的toString方法
        System.out.println("=========3.1使用增强for==========");
        for (Object o : arrayList) {
            String col1=(String) o;
            System.out.println(col1);
        }
        //迭代器是专门用来遍历集合的一种方式
        System.out.println("=========3.2使用iterator迭代器==========");
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()){
            String col2 = (String)iterator.next();
            System.out.println(col2);
            //java.util.ConcurrentModificationException 并发修改异常，也就是说，再遍历集合的时候，是不能够删除集合中的元素的。
            //arrayList.remove(col2);
            //要想在遍历的时候删除集合中的元素可以使用迭代器提供的删除方法进行删除
//            iterator.remove();
        }
        System.out.println("集合大小===="+arrayList.size());
        System.out.println("=========3.3使用普通for循环进行遍历==========");
        for (int i = 0; i <arrayList.size() ; i++) {
            System.out.println(((ArrayList) arrayList).get(i));
        }
        //使用列表迭代器，和iterator的区别，listiterator可以向前或者向后遍历，添加、删除、修改元素。
        System.out.println("=========3.4使用列表迭代器从前往后遍历==========");
        ListIterator listIterator = arrayList.listIterator();
        while (listIterator.hasNext()) {
            System.out.println(listIterator.nextIndex()+":"+listIterator.next());
        }
        System.out.println("=========3.4使用列表迭代器从后往前遍历==========");
        while (listIterator.hasPrevious()) {
            System.out.println(listIterator.previousIndex()+":"+listIterator.previous());
        }
        //3.5 判断
        System.out.println(arrayList.contains("apple"));
        System.out.println(arrayList.isEmpty());
        //3.6 获取元素在集合中的位置
        System.out.println(arrayList.indexOf("Durian"));
        System.out.println(arrayList.indexOf("apple"));
    }
}

运行结果：
集合大小====3
集合遍历====[Durian, apple, bananer]
=========3.1使用增强for==========
Durian
apple
bananer
=========3.2使用iterator迭代器==========
Durian
apple
bananer
集合大小====3
=========3.3使用普通for循环进行遍历==========
Durian
apple
bananer
=========3.4使用列表迭代器从前往后遍历==========
0:Durian
1:apple
2:bananer
=========3.4使用列表迭代器从后往前遍历==========
2:bananer
1:apple
0:Durian
true
false
0
1

*小案例*

package com.practise;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/**
 * list子接口的使用
 * 特点：有序 有下标 可以重复
 */
public class Demo04 {
    public static void main(String[] args) {
        //创建集合
        List list = new ArrayList();
//      * 1.添加元素(自动装箱，也就是在添加基本数据类型的时候，集合就会将添加的基本数据类型自动转换成该元素对应的包装类)
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        list.add(60);
        System.out.println("集合大小===="+list.size());
        System.out.println("集合遍历===="+list);//默认重写的toString方法
        //2.删除元素
        //java.lang.IndexOutOfBoundsException: Index: 20, Size: 5  直接写的话是按照下标删除的，所以会报这下标越界的异常
//        list.remove(20);//这样写是会报错的
//        list.remove((Object)20);//这样写是可以的
//        list.remove((Integer)20);//这样写也是可以的
//        System.out.println("集合大小===="+list.size());
//        System.out.println("集合遍历===="+list);//默认重写的toString方法

        //3.获取子集合 subList [ int fromIndex, int toIndex )
        List subList = list.subList(1, 3);
        System.out.println("集合大小===="+subList.size());
        System.out.println("集合遍历===="+subList);//默认重写的toString方法
    }
}

运行结果；
集合大小====5
集合遍历====[20, 30, 40, 50, 60]
集合大小====2
集合遍历====[30, 40]

*解决新创建的对象是否在集合中已经存在*

package com.practise;


/**
 * 学生类
 */
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 +
                '}';
    }

    /**
     * 重写object类的equals方法
     * @param o
     * @return
     */
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if(o==null) return false;
        //3.判断是否是Student类型
        if(o instanceof Student){
            Student student = (Student) o;
            //比较属性，这个可以自己定义
            if(this.name.equals(student.getName())&&this.getAge()==(student.getAge())){
                return true;
            }
        }

        return false;
    }

    public static void main(String[] args) {
        System.out.println(0>>1);
    }

}

package com.practise;

import java.util.ArrayList;
import java.util.List;

/**
 * ArrayList子接口的使用
 * 特点：有序 有下标 可以重复
 */
public class Demo05 {
    public static void main(String[] args) {
        //创建集合
        List list = new ArrayList();
//         * 1.添加元素(自动装箱，也就是在添加基本数据类型的时候，集合就会将添加的基本数据类型自动转换成该元素对应的包装类)
        Student stu1 = new Student("张三", 18);
        Student stu2 = new Student("李四", 19);
        Student stu3 = new Student("王五", 20);
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);
        System.out.println("集合大小===="+list.size());
        System.out.println("集合遍历===="+list);//默认重写的toString方法
        //2.删除元素
//        list.remove(new Student("张三", 18));//必须重写object的equals方法。
//        System.out.println("集合大小===="+list.size());
//        System.out.println("集合遍历===="+list);//默认重写的toString方法
        //3.判断
        System.out.println(list.contains(new Student("张三", 18)));//现在就有了 true
        //4.查找
        System.out.println(list.indexOf(new Student("张三", 18)));//现在就有了 位置为0 第一个

    }
}

运行结果：
集合大小====3
集合遍历====[Student{name='张三', age=18}, Student{name='李四', age=19}, Student{name='王五', age=20}]
true
0

//这是使用一种连缀写法的遍历方式

import java.util.ArrayList;

public class B {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("hello1");
        list.add("hello2");
        list.add("hello3");
        list.add("hello4");
        //这个item表示的就是集合遍历过程中的单个元素
        list.stream().forEach(yyy->{
            if(yyy.equals("hello2")){
                yyy="hello22222";
                //return;
            }
            System.out.println("============="+yyy);
        });
    }

}

将两个list集合合并成一个list集合

public abstract class Test<T> {
    public static void main(String[] args) {
        HashMap<String, Object> map1 = new HashMap<>();
        map1.put("a","aa");
        map1.put("b","bb");
        map1.put("c","cc");
        HashMap<String, Object> map2 = new HashMap<>();
        map2.put("d","dd");
        map2.put("e","ee");
        map2.put("f","gg");
        ArrayList arrayList1 = new ArrayList();
        arrayList1.add(map1);
        arrayList1.add(map2);

        HashMap<String, Object> map3 = new HashMap<>();
        map3.put("g","gg");
        map3.put("h","hh");
        map3.put("i","ii");
        HashMap<String, Object> map4 = new HashMap<>();
        map4.put("j","jj");
        map4.put("k","kk");
        map4.put("l","ll");
        ArrayList arrayList2 = new ArrayList();
        arrayList2.add(map3);
        arrayList2.add(map4);
        arrayList2.addAll(arrayList1);
        System.out.println(arrayList2);


    }
}

运行结果:
[{g=gg, h=hh, i=ii}, {j=jj, k=kk, l=ll}, {a=aa, b=bb, c=cc}, {d=dd, e=ee, f=gg}]
由此可见，进行合并之后，这是一个集合。