Java--集合框架--ArrayList、 Vector、 LinkedList、 泛型(Generic) 、 可变参数 、增强for循环

于 2020-02-15 16:07:05 发布
阅读量208 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43216479/article/details/104320148
版权 
ArrayList
Vector
LinkedList
泛型(Generic)

可变参数
增强for循环

集合框架(ArrayList存储字符串并遍历)

​	JDK1.8新增的一个方法也能遍历集合
​	void forEach(Consumer<? super E> action) 执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常 
A:案例演示:	ArrayList存储自定义对象并遍历
		迭代器
		普通for
public class MyTest{
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("aaaaa");
        arrayList.add("ccccc");
        arrayList.add("bbbbb");
        arrayList.add("dddddd");
        arrayList.add("eeeeee");

        arrayList.forEach(new MyConsumer());
        
    }
}
class MyConsumer implements Consumer<String>{

    @Override
    public void accept(String s) {
        System.out.println(s);
    }
}

集合框架(Vector的特有功能)

A:Vector类概述:	Vector 类可以实现可增长的对象数组 , Vector 是同步的。 
B:Vector类特有功能
	public void addElement(E obj)
	public E elementAt(int index)
	public Enumeration elements()
C:案例演示:	Vector的特有功能演示
public class MyTest {
    public static void main(String[] args) {
        Vector vector = new Vector();
        vector.addElement(100);
        vector.addElement(200);
        vector.addElement(300);
        vector.addElement(400);

        Object o = vector.elementAt(0);
        Object o1 = vector.firstElement();
        Object o2 = vector.lastElement();

        vector.removeElement(100);
        vector.removeAllElements();;
    }
}

集合框架(LinkedList的特有功能)

A:LinkedList类概述:  List 接口的链接列表实现 , 此实现不是同步的
B:LinkedList类特有功能
	public void addFirst(E e)及addLast(E e)
	public E getFirst()及getLast()
	public E removeFirst()及public E removeLast()
C:案例演示	
	LinkedList的特有功能演示
public class MyTest {
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        linkedList.addFirst(100);
        linkedList.addFirst(200);
        linkedList.addFirst(300);
        System.out.println(linkedList);

        Object peek = linkedList.peek();
        System.out.println(peek);
        Object peek1 = linkedList.peek();
        System.out.println(peek1);

        Object pop = linkedList.pop();
        System.out.println(pop);


        Object poll = linkedList.poll();
        System.out.println(poll);
        System.out.println(linkedList);

        Object poll1 = linkedList.poll();
        System.out.println(poll1);
        System.out.println(linkedList);

    }
}

集合框架(用LinkedList模拟栈数据结构的集合并测试)

A:案例演示:	需求：请用LinkedList模拟栈数据结构的集合，并测试
public class MyTest {
    public static void main(String[] args) {
        MyList myList = new MyList();
        myList.add(100);
        myList.add(200);
        myList.add(300);
        myList.add(400);
        myList.add(500);

        Object obj= myList.get();
        System.out.println(obj);
        obj= myList.get();
        System.out.println(obj);
        obj= myList.get();
        System.out.println(obj);
    }
}
public class MyList {
    private LinkedList linkedList=null;
    public MyList() {
    linkedList=new LinkedList();
    }

    public void add(Object obj) {
        linkedList.addFirst(obj);
        
    }

    public Object get() {
        Object poll = linkedList.poll();
        linkedList.addLast(poll);
        return  poll;
    }
}

集合框架(去除ArrayList中重复字符串元素方式)

A:案例演示
	需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
	思路：创建新集合方式
public class MyTest {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("aaa");
        list.add("aaa");
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("eee");

        ArrayList newList = new ArrayList();
        for (int i = 0; i < list.size(); i++) {
            Object o = list.get(i);
            if (!newList.contains(o)){
                newList.add(o);
            }
        }
        System.out.println(newList);
    }
}

集合框架(去除ArrayList中重复自定义对象元素)

A:案例演示
	需求：ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)
B:注意事项
	重写equals()方法
public class MyTest2 {
    public static void main(String[] args) {
        Student s1 = new Student("张三", 22);
        Student s2 = new Student("张三", 22);
        Student s3 = new Student("李四", 20);
        Student s4 = new Student("李四", 20);
        Student s5 = new Student("王五", 24);
        Student s6 = new Student("王五", 24);

        ArrayList list = new ArrayList();
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);
        list.add(s5);
        list.add(s6);

        ArrayList newList = new ArrayList();
        for (int i = 0; i < list.size(); i++) {
            Student student =(Student) list.get(i);
            if (!newList.contains(student)){
                newList.add(student);
            }
        }

        for (int i = 0; i < newList.size(); i++) {
            Object o = list.get(i);
            System.out.println(o);
        }
    }
}
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 +
                '}';
    }

    @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);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

集合框架(泛型概述和基本使用)

A:泛型概述:是一种把类型明确的工作
推迟到创建对象
或者调用方法的时候才去明确的特殊的类型。
参数化类型，把类型当作参数一样的传递。
B:泛型的格式	:	<数据类型>	这里的数据类型只能是引用数据类型
C:泛型好处
	(1): 把运行时期的问题提前到了编译期间
	(2): 避免了强制类型转换
	(3):优化了程序设计，解决了黄色警告线
	注意：泛型只在编译期有效  但在运行期就擦除了
D:泛型基本使用

集合框架(ArrayList存储字符串并遍历泛型版)

A:案例演示:	ArrayList存储字符串并遍历泛型版
public class MyTest {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("aaaaa");
        strings.add("aaaaa");
        strings.add("aaaaa");

        String s = strings.get(0);

        Iterator<String> iterator = strings.iterator();
        while (iterator.hasNext()){
            String next = iterator.next();
            System.out.println(next);
        }
    }
}

集合框架(泛型的由来)

A:ObjectTool
	泛型的由来:通过Object转型问题引入
	早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。
	也就存在这隐患，所以Java提供了泛型来解决这个安全问题。

集合框架(泛型类的概述及使用)

A:泛型类概述:	        把泛型定义在类上
B:定义格式:		public class 类名<泛型类型1,…>
C:注意事项:		泛型类型必须是引用类型
D: 案例演示:泛型类的使用
- 泛型的应用之泛型类: 就是把泛型定义在类上
- 格式:		public class 类名<数据类型 , ....> {}
public class MyTest {
    public static void main(String[] args) {
        MyClass<Integer, String, Double> aMyClass = new MyClass<>();
        aMyClass.setH("abc");
        aMyClass.setM(200);
        String h = aMyClass.getH();
        System.out.println(h);
        Integer m = aMyClass.getM();
        System.out.println(m);

    }
}
public class MyClass<M,H,R> {
    private M m;
    private H h;

    public M getM() {
        return m;
    }

    public void setM(M m) {
        this.m = m;
    }

    public H getH() {
        return h;
    }

    public void setH(H h) {
        this.h = h;
    }

    public String get(R r){
        return "abc";
    }
}

集合框架(泛型方法的概述和使用)

A:泛型方法概述:	把泛型定义在方法上
B:定义格式:		public <泛型类型> 返回类型 方法名(泛型类型 变量名)
C:案例演示:		泛型方法的使用
public class MyTest{
    public static void main(String[] args) {
        MyHaha myHaha = new MyHaha();
        myHaha.show(3.14);
    }
}
public class MyHaha {
    public <T> void show(T num){
        System.out.println(num);
    }
}

集合框架(泛型接口的概述和使用)

A:泛型接口概述:	把泛型定义在接口上
B:定义格式:		public interface 接口名<泛型类型>
C:案例演示:		泛型接口的使用
public class MyTest {
    public static void main(String[] args) {
        new MyInterface<Integer>(){
            @Override
            public void test(Integer integer) {

            }
        };
    }
}
public interface MyInterface<T> {
    void test(T t);
}

集合框架(泛型高级之通配符)

A:泛型通配符<?>:		任意类型，如果没有明确，那么就是Object以及任意的Java类了
B:? extends E:			向下限定，E及其子类
C:? super E:			向上限定，E及其父类
D:案例演示: 泛型高级之通配符的基本使用
public class MyTest {
    public static void main(String[] args) {
        ArrayList<Animal> animals = new ArrayList<>();
        ArrayList<Dog> animals2 = new ArrayList<>();

        ArrayList<?> animals3 = new ArrayList<>();
        ArrayList<?> animals4 = new ArrayList<>();

        ArrayList<? super Animal> animals5 = new ArrayList<Animal>();
        ArrayList<? super Animal> animals6 = new ArrayList<Object>();

        ArrayList<? extends Animal> animals7 = new ArrayList<Cat>();
        ArrayList<? extends Animal> animals8 = new ArrayList<Dog>();

        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(100);

        ArrayList<Integer> integers2 = new ArrayList<>();
        integers.add(200);

        integers.addAll(integers2);
    }
}
class Animal{}
class Dog extends Animal{}
class Cat extends Animal{}

	/**
	 * 泛型如果明确了数据类型以后,那么要求左右两边的数据类型必须一致
	 */
	Collection<Object> col1 = new ArrayList<Object>() ;
	Collection<Object> col2 = new ArrayList<Animal>() ;//报错

	// ? 表示任意的数据类型
	Collection<?> col5 = new ArrayList<Object>() ;
	Collection<?> col6 = new ArrayList<Animal>() ;

	// ? extends E : 向下限定	, ? 表示的是E或者E的子类



//		Collection<? extends Animal> col9 = new ArrayList<Object>() ;//报错
		Collection<? extends Animal> col10 = new ArrayList<Animal>() ;
		Collection<? extends Animal> col11 = new ArrayList<Dog>() ;


	// ? super E:  向上限定 , ? 表示的是E或者E的父类
	Collection<? super Animal> col13 = new ArrayList<Object>() ;
	Collection<? super Animal> col14 = new ArrayList<Animal>() ;


//		Collection<? super Animal> col15 = new ArrayList<Dog>() ;//报错

集合框架(增强for的概述和使用)

A:增强for概述
	简化数组和Collection集合的遍历
B:格式：
	for(元素数据类型 变量 : 数组或者Collection集合) {
		使用变量即可，该变量就是元素
	}
C:案例演示
	数组，集合存储元素用增强for遍历
public class MyTest {
    public static void main(String[] args) {

        int[] arr={10,20,30,40};
        /*for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }*/

        for (int ele:arr){
            System.out.println(ele);
        }

        ArrayList<Integer> list = new ArrayList<>();
        list.add(100);
        list.add(200);
        list.add(100);
        list.add(300);
        list.add(400);
        list.add(500);

        for (Integer ele:list){
            System.out.println(ele);
        }
    }
}
D:好处和注意事项
	简化遍历
	注意事项：增强for的目标要判断是否为null
	注意新式for循环，你在迭代集合的途中，不能增删元素，会报并发修改异常

集合框架(可变参数的概述和使用)

A:可变参数概述:	定义方法的时候不知道该定义多少个参数
B:格式:			修饰符 返回值类型 方法名(数据类型…  变量名){}
C:注意事项：
	a:	这里的变量其实是一个数组
	b:	如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个


	// 可变参数
public static int add(int... a){
	
	// 定义一个累加变量
	int sum = 0 ;
	
	for(int s : a ){
		sum += s ;
	}
	
	return sum;
}

集合框架(Arrays工具类的asList()方法的使用)

A:案例演示:	Arrays工具类的asList(T... t)方法的使用:		将数组转换成集合
public class MyTest {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(100);
        list.add(200);
        list.add(100);
        list.add(300);
        list.add(400);
        list.add(500);

        Object[] objects = list.toArray();

        Integer[] integers={20,30,40};
        List<Integer> integers1 = Arrays.asList(integers);
        for (Integer integer : integers1) {
            System.out.println(integer);
        }

        Integer[] integers2={20,30,40};
        Integer[] integers3={20,30,40};
        List<Integer[]> list1 = Arrays.asList(integers2, integers3);

       /* Integer integer = list1.get(1)[2];
        System.out.println(integer);
*/
        for (Integer[] integers4 : list1) {
            System.out.println(integers4);
            for (Integer integer : integers4) {
                System.out.println(integer);
            }
        }

        Integer[] integers4={200,300,600};
        int[] arr={1,2,3};
        List<Integer> integers5 = Arrays.asList(integers4);
        List<int[]> ints=Arrays.asList(arr);
    }
}

	注意事项:	得到的集合长度是不可变的 你不能往这个转换后的集合中 添加元素（add） 和 删除元素(remove)
			只能获取元素(get)

集合框架(集合嵌套之ArrayList嵌套ArrayList)

A:需求：
	我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList<Student>
	但是呢，我们旁边是不是还有班级，每个班级是不是也是一个ArrayList<Student>。	
	而我现在有多个ArrayList<Student>。也要用集合存储，怎么办呢?
	集合嵌套之ArrayList嵌套ArrayList

	// 定义大的集合
	ArrayList<ArrayList<Student>> allClassList = new  ArrayList<ArrayList<Student>>() ;
	
	// 创建每一个班的集合
	ArrayList<Student> jcClassList = new  ArrayList<Student>() ;

public class MyTest {
    public static void main(String[] args) {
        Student s1 = new Student("一一",20);
        Student s2 = new Student("二二",18);
        Student s3 = new Student("三三",22);
        Student s4 = new Student("四四",23);
        Student s5 = new Student("五五",20);
        Student s6 = new Student("六六",21);
        ArrayList<Student> javaList = new ArrayList<>();
        javaList.add(s1);
        javaList.add(s2);

        ArrayList<Student> phpList = new ArrayList<>();
        javaList.add(s3);
        javaList.add(s4);

        ArrayList<Student> webList = new ArrayList<>();
        javaList.add(s5);
        javaList.add(s6);

       ArrayList<ArrayList<Student>>  maxList = new ArrayList<>();
       maxList.add(javaList);
       maxList.add(phpList);
       maxList.add(webList);
        //方式一
        for (int i = 0; i < maxList.size(); i++) {
            ArrayList<Student> students = maxList.get(i);
            for (int j = 0; j < students.size(); j++) {
                Student student = students.get(j);
                System.out.println(student.getName()+"==="+student.getAge());

            }
        }

        //方式二
        for (ArrayList<Student> students : maxList) {
            for (Student student : students) {
                System.out.println(student.getName()+"==="+student.getAge());
            }
        }
    }
}

public class Student {
    private String name;
    private int age;


    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;
    }
}
全宇宙最可爱的宇宙
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值