JavaSE--集合框架

最新推荐文章于 2024-04-24 09:25:21 发布

「已注销」

最新推荐文章于 2024-04-24 09:25:21 发布

阅读量144

点赞数 3

分类专栏： JavaSE

本文链接：https://blog.csdn.net/Augueste/article/details/117226900

版权

JavaSE 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Java--集合框架

对象数组

案例演示
需求：我有3个学生，请把这3个学生的信息存储到数组中，并遍历数组，获取到每一个学生的信息
学生：Student
成员变量：name,age
构造方法：无参，带参
成员方法：getXxx()/setXxx()
存储学生的数组
测试类：

package org.westos.demo1;
public class MyTest {
    public static void main(String[] args) {
        /*A:
        案例演示
        需求：我有3个学生，请把这个3个学生的信息存储到数组中，并遍历数组，获取得到每一个学生信息。*/

        Student s1 = new Student("张三", 23);
        Student s2 = new Student("李四", 24);
        Student s3 = new Student("王五", 25);
        Student s4 = new Student("赵六", 26);
        //定义数组 对象数组
        Student[] arr = {s1, s2, s3};

        for (int i = 0; i < arr.length; i++) {

            Student student = arr[i];
            System.out.println(student.getName() + "====" + student.getAge());
        }
    }

Student类

package org.westos.demo1;
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 +
                '}';
    }
}

Teacher类

package org.westos.demo1;
public class Teacher {

}

运行结果
在这里插入图片描述

集合

集合的由来：面向对象语言对事物的体现都是以对象的形式，所以为了方便对象的操作，Java就提供了集合类
数组和集合的区别
a.长度区别：
数组的长度是固定的而集合的长度是可变的
b.存储数据类型的区别
数组可以存储基本类型，也可以存储引用数据类型；而集合只能存储引用数据类型
c.内容区别
数组只能存储同种数据类型的元素，集合可以存储不同类型的元素
集合继承体系图

Collection集合的功能

功能描述
a.添加功能
boolean add(Object obj):添加一个元素
boolean addAll(Collection c):添加一个集合的元素 (给一个集合添加进另一个集合中的所有元素)
b.删除功能
void clear():移除所有元素
boolean remove(Object o):移除一个元素
boolean removeAll(Collection c):移除一个集合的元素(移除一个以上返回的就是true) 删除的元素是两个集合的交集元素
如果没有交集元素则删除失败返回false
c.判断功能
boolean contains(Object o)：判断集合中是否包含指定的元素
boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(这个集合包含另一个集合中所有的元素才算包含才返回true)
比如：1，2，3 containsAll 12=true 1,2,3 containsAll 2,3,4=false
boolean isEmpty()：判断集合是否为空
d:获取功能
Iterator iterator()(重点)
e:长度功能
int size():元素的个数

面试题

数组有没有length()方法呢?字符串有没有length()方法呢?集合有没有length()方法呢？

f:交集功能
例如：A集合对B集合取交集，获取到的交集元素在A集合中。返回的布尔值表示的是A集合是否发生变化
A集合对B集合取交集元素，如果没有取到交集元素A集合会被清空
boolean retainAll(Collection c):获取两个集合的交集元素(交集：两个集合都有的元素)
g:把集合转换为数组
Object[] toArray()

案例演示：Collection集合的基本功能测试
boolean add(E e)
boolean remove(Object o)
void clear()
boolean contains(Object o)
boolean isEmpty()
int size()

package org.westos.demo2;
import java.util.ArrayList;
import java.util.Collection;
public class Test1 {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        //往容器中添加内容 add()
        boolean b = list.add("张三");
        list.add("李四");
        list.add("王五");
        System.out.println(list);
    }
}

在这里插入图片描述

package org.westos.demo2;
import java.util.ArrayList;
import java.util.Collection;
public class Test2 {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        list.add("abc");
        int num = 200;
        list.add(100);
        //自动装箱的机制
        list.add(num);
        list.add(new Integer(500));
        list.add(Integer.valueOf(num));
    }
}

在这里插入图片描述

案例演示：Collection集合的高级功能测试
boolean addAll(Collection c)
boolean removeAll(Collection c)
boolean containsAll(Collection c)
boolean retainAll(Collection c)

package org.westos.demo2;
import java.util.ArrayList;
import java.util.Collection;
public class Test3 {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        list.add(200);
        list.add(200);
        list.add(300);

        Collection list2 = new ArrayList();
        list2.add(2);
        list2.add(3);
        list2.add(4);
        //A集合addAll(B集合); 把B集合的元素放到A集合中，但是B集合元素不会发生改变
        boolean b = list.addAll(list2);

        System.out.println(list);
        System.out.println(list2);

    }
}

在这里插入图片描述

package org.westos.demo2;
import java.util.ArrayList;
import java.util.Collection;
public class Test4 {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        list.add(200);
        list.add(200);
        list.add(300);

        //清空集合中的元素
        //list.clear();
        //删除单个元素
        list.remove(200);
        System.out.println(list);
    }
}

在这里插入图片描述

package org.westos.demo2;
import java.util.ArrayList;
import java.util.Collection;
public class Test5 {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        list.add(200);
        list.add(400);
        list.add(300);
        list.add(1);

        Collection list2 = new ArrayList();
        list2.add(2);
        list2.add(3);
        list2.add(4);
        list2.add(400);
        list2.add(200);
        //A集合removeAll(B); A集合中会删除掉两个集合中的交集元素，B集合不会发生变化。返回值的意思就是如果有交集元素被删除就返回true
        boolean b = list.removeAll(list2);
        System.out.println(b);
        System.out.println(list);
        System.out.println(list2);
    }
}

在这里插入图片描述

package org.westos.demo2;
import java.util.ArrayList;
import java.util.Collection;
public class Test6 {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        list.add(200);
        list.add(400);
        list.add(300);
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(10);
        list.add(5555);

        Collection list2 = new ArrayList();
        list2.add(2);
        list2.add(3);
        list2.add(4);
        list2.add(400);
        list2.add(10);
        list2.add(200);
        //A集合containsAll(B集合); A集合中的元素是否包含了B集合中所有的元素，包含了就返回true,没有就返回false
        boolean b = list.containsAll(list2);
        System.out.println(b);
    }
}

在这里插入图片描述

集合的遍历之集合转数组遍历

集合的遍历
toArray()把一个集合转成数组[其实就是依次获取集合中的每一个元素]
案例演示：把集合转成数组toArray()，遍历这个数组可以实现集合的遍历

package org.westos.demo2;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
public class Test7 {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        list.add(200);
        list.add(400);
        list.add(300);
        list.add(1);
        //把集合转换成数组
        int size = list.size();
        Integer[] arr = new Integer[size];
        Iterator iterator = list.iterator();
        int i = 0;
        while (iterator.hasNext()) {
            Integer next = (Integer) iterator.next();
            arr[i] = next;
            i++;
        }
        System.out.println(Arrays.toString(arr));
        System.out.println("===========================================");
        //把集合转换成数组。
        Object[] objects = list.toArray();
          /*public Object[] toArray() {
                        return Arrays.copyOf(elementData, size);*/
                }

    }

在这里插入图片描述

案例演示：Collection存储自定义对象并遍历
Collection存储自定义对象并把集合转成对象数组遍历

package org.westos.demo2;
import org.westos.demo1.Student;
import java.util.ArrayList;
import java.util.Collection;
public class Test8 {
    public static void main(String[] args) {
        // 创建集合对象
        Collection c = new ArrayList();
        // 创建学生对象
        Student s1 = new Student("张三", 27);
        Student s2 = new Student("李四", 30);
        Student s3 = new Student("王麻子", 33);
        Student s4 = new Student("刘五", 25);
        Student s5 = new Student("宋六", 22);
        // 把学生添加到集合
        c.add(s1);
        c.add(s2);
        c.add(s3);
        c.add(s4);
        c.add(s5);
        // 把集合转成数组
        Object[] objs = c.toArray();
        // 遍历数组
        for (int x = 0; x < objs.length; x++) {
            // System.out.println(objs[x]);
            Student s = (Student) objs[x];
            System.out.println(s.getName() + "---" + s.getAge());
        }
    }
}

在这里插入图片描述

集合的遍历之迭代器遍历

迭代器概述：对Collection进行迭代的迭代器
案例演示：迭代器的使用

迭代器的原理及源码分析

迭代器原理：
为什么迭代器不定义成一个类，而是定义成一个接口
迭代器源码分析

 public interface Iterator<E>{
            *Returns (@code true ) if the iteration has more Elements,
            boolean haseNext();
            *Returns  the next element in the iterator,[]
            E next();
            * Removes from the underlying collection the last element returned
            void remove();
        }

java提供的迭代器的接口中定义了三个方法：

hasNext() ：判断是否还有元素
next() ：获取指向的元素
remove() ：删除指向的元素
上面只是java定义的接口，想弄清楚具体的原理，我们还需要查看具体的实现，也就是迭代器接口的具体的实现
什么样的容器可以使用迭代器进行遍历元素呢？

要想使用迭代器进行遍历的容器必须实现Iterable接口，先来看看Iterable接口定义了哪儿方法：

public interface Iterator<T>{
          *Returns an iterator Over a set of elements of type T. 
                Iterator<T> iterator();
    }

通过源码的查看，Iterable接口中只定义了一个方法，也就是获取迭代器的方法，故一个容器需要使用迭代器进行遍历，必须给出具体的迭代器的方法。我们知道单例集合可以使用迭代器遍历，那么单例集合一定也继承能了该接口。

public interface Collection <E> extends Iterable<E>{
##ArrayList集合迭代器实现
ArrayList作为Collection接口的具体的子实现类，必须重写父接口中所有的抽象方法，包括Iterator接口获取iterator（）方法
}

Collection集合存储字符串并遍历

练习：Collection集合存储字符串并遍历
迭代器的方式

public class MyTest {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        list.add(200);
        list.add(400);
        list.add(300);
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(10);
        list.add(5555);


        // int size = list.size();
        // System.out.println(size);

        //我们采用迭代器
        //
    java.util   接口 Iterator<E>
       boolean hasNext ()  如果仍有元素可以迭代，则返回 true。

          E next ()        返回迭代的下一个元素
        Iterator iterator = list.iterator(); //获取迭代器
        System.out.println(iterator);
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println(obj);
        }
    }
}

在这里插入图片描述

Collection集合存储自定义对象并遍历

练习：Collection集合存储自定义对象并遍历
迭代器的方式

 import java.util.Collection;
import java.util.Iterator;
/*
 * 需求：存储字符串并遍历。
 * 
 * 分析：
 *   A:创建集合对象
 *   B:创建字符串对象
 *   C:把字符串对象添加到集合中
 *   D:遍历集合
 */
public class CollectionTest {
 public static void main(String[] args) {
  // 创建集合对象
  Collection c = new ArrayList();
  // 创建字符串对象
  // 把字符串对象添加到集合中
  c.add("林青霞");
  c.add("风清扬");
  c.add("刘意");
  c.add("武鑫");
  c.add("刘晓曲");
  // 遍历集合
  // 通过集合对象获取迭代器对象
  Iterator it = c.iterator();
  // 通过迭代器对象的hasNext()方法判断有没有元素
  while (it.hasNext()) {
   // 通过迭代器对象的next()方法获取元素
   String s = (String) it.next();
   System.out.println(s);
  }
 }
}

在这里插入图片描述

List概述及特点以及存储字符串并遍历

List概述及特点：元素有序，并且每一个元素都存在一个索引，元素可以重复
案例演示：List集合存储字符串并遍历
迭代器的方式

package org.westos.demo3;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class List存储字符串并并遍历 {

	public static void main(String[] args) {
		//创建集合对象
      List s = new ArrayList();
      
      //创建字符串添加字符串
      s.add("hellow");
      s.add("word");
      s.add("java");
      
      //遍历字符串
      Iterator it = s.iterator();
      
      while(it.hasNext()) {
    	  String a = (String) it.next();
    	  System.out.println(a);
      }
	}
}

在这里插入图片描述

List集合存储学生对象并遍历

案例演示： List集合存储学生对象并遍历
迭代器的方式

package org.westos.demo3;
import org.westos.demo1.Student;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Demo3 {
    public static void main(String[] args) {
        //创建List集合对象
        List<Student> list = new ArrayList<Student>();
        //创建学生对象
        Student s1 = new Student("Tom",4);
        Student s2 = new Student("Bob",6);
        Student s3 = new Student("Mia",5);
        //把学生添加到集合
        list.add(s1);
        list.add(s2);
        list.add(s3);
        //遍历集合
        Iterator<Student> it = list.iterator();
        while(it.hasNext()){
            Student s = it.next();
            System.out.println(s.getName()+','+s.getAge());
        }
        System.out.println("…………………………………………");
        for (int i=0; i<list.size(); i++){
            Student s = list.get(i);
            System.out.println(s.getName()+','+s.getAge());
        }
    }
}

在这里插入图片描述

List集合的特有功能概述和测试

List集合的特有功能概述
void add(int index,E element): 在指定索引处添加元素
E remove(int index):移除指定索引处的元素返回的是移除的元素
E get(int index):获取指定索引处的元素
E set(int index,E element):更改指定索引处的元素返回的而是被替换的元素
int indexOf(Object o)
返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
int lastIndexOf(Object o)
返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1
案例演示: 特有功能测试

package org.westos.demo3;
import java.util.ArrayList;
import java.util.List;
public class Demo01_List {
	public static void main(String[] args) {
		//demo1();
		//demo2();
		//demo3();
		//demo4();
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		
		list.set(1, "z");						//将指定位置的元素修改
		System.out.println(list);
	}
	public static void demo4() {
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		//Object obj1 = list.get(2);
		//System.out.println(obj1);
		//通过索引遍历List集合
		for(int i = 0;i < list.size(); i++) {
			System.out.println(list.get(i));
		}
	}
	public static void demo3() {
		List list = new ArrayList();
		list.add(111);
		list.add(222);
		list.add(333);
		list.remove(111);							//删除的时候不会自动装箱,而是把111当作索引
		System.out.println(list);
	}
	public static void demo2() {
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		Object obj = list.remove(1);				//通过索引删除元素,将被删除的元素返回
		System.out.println(obj);
		System.out.println(list);
	}
	public static void demo1() {
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		list.add(4, "f");						//index<=size并且index>=0都不会报异常
		//list.add(1,"e");
		//list.add(10, "z");					//java.lang.IndexOutOfBoundsException,当存储时使用不存在的索引时
		System.out.println(list);
	}
}

在这里插入图片描述

List集合的特有遍历功能

案例演示: 使用for循环通过size()和get()方法结合使用遍历

ackage org.westos.demo3;
import org.westos.demo1.Student;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/*
 * 
 * 存储自定义对象并遍历，用for循环（size（）方法和get（）方法结合）
 * 
 */
public class List练习 {
	public static void main(String[] args) {
		//创建集合
		List list = new ArrayList();
       //创建学生对象
		 Student s1 = new  Student("黎明",321);
		 Student s2 = new  Student("黎",31);
		 Student s3 = new  Student("明",23);
		 //添加元素
		 list.add(s1);
		 list.add(s2);
		 list.add(s3);
		 //遍历
		 //用迭代器
		 Iterator it  = list.iterator();
		 while(it.hasNext()) {
			 Student x =(Student) it.next();
			 System.out.println(x.getName()+"----"+x.getAge());
		 }
	    //用for循环
		 for(int x= 0;x<list.size();x++) {
			 Student g = (Student)list.get(x);
			 System.out.println(g.getName()+"----"+g.getAge());
		 }
	}
}

在这里插入图片描述

ListIterator的特有功能

ListIterator 继承自Iterator 可以使用Iterator中的方法
ListIterator的特有功能
boolean hasPrevious(): 是否存在前一个元素
E previous(): 返回列表中的前一个元素
以上两个方法可以实现反向遍历但是注意要完成反向遍历之前要先进行正向遍历这样指针才能移到最后
如果直接反向遍历是没有效果的因为指针默认位置就在最前面他前面没有元素
案例演示：ListIterator的特有功能

//创建集合对象
		List list=new ArrayList();
		
		list.add("hello");
		list.add("world");
		list.add("java");
		
		ListIterator it=list.listIterator();
		while(it.hasNext()){
			String s=(String)it.next();
			System.out.println(s);
		}
		System.out.println("---------");
		
		while(it.hasPrevious()){
			String s2=(String) it.previous();
			System.out.println(s2);
		}
		System.out.println("---------");
		Iterator its=list.iterator();
		while(its.hasNext()){
			String s1=(String) its.next();
			System.out.println(s1);
		}

在这里插入图片描述

并发修改异常产生的原因及解决方案

案例演示：需求：我有一个集合，请问，我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现

ConcurrentModificationException出现
我们用Iterator这个迭代器遍历采用hasNext方法和next方法，集合修改集合会出现并发修改异常
原因是我们的迭代依赖与集合当我们往集合中添加好了元素之后获取迭代器那么迭代器已经知道了集合的元素个数
这个时候你在遍历的时候又突然想给集合里面加一个元素（用的是集合的add方法）那迭代器不同意就报错了
解决方案1 我们用ListIterator迭代器遍历用迭代器自带的add方法添加元素那就不会报错了
a:迭代器迭代元素，迭代器修改元素(ListIterator的特有功能add)
b:集合遍历元素，集合修改元素

解决方案2 使用for循环遍历集合添加元素不会报错

public class MyTest3 {
    public static void main(String[] args) {
        // 需求：我有一个集合，请问，我想判断里面有没有 "world" 这个元素，如果有，我就添加一个 "javaee" 元素，请写代码实现
        List list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("eee");
        list.add("world");
     /*   if (list.contains("world")) {
            list.add("javaee");
        }
        System.out.println(list);*/
        /*
         *  ConcurrentModificationException 并发修改异常。
         *
         *我们用Iterator这个迭代器遍历采用hasNext方法和next方法，集合修改集合 会出现并发修改异常
	原因是我们的迭代依赖与集合 当我们往集合中添加好了元素之后 获取迭代器  那么迭代器已经知道了集合的元素个数
	这个时候你在遍历的时候又突然想给 集合里面加一个元素（用的是集合的add方法） 那迭代器不同意 就报错了
         *
         *
         * */
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            String ele = (String) listIterator.next();
            if ("world".equals(ele)) {
                //list.add("javaee");
                //list.remove("aaa");
                listIterator.add("javaee");
                //listIterator.remove();
            }
        }
        System.out.println(list);
        //解决方案
        //采用for循环
     /*   for (int i = 0; i < list.size(); i++) {
            String ele = (String) list.get(i);
            if ("world".equals(ele)) {
                list.add("javaee");
            }
        }

        System.out.println(list);*/

        //你用迭代器遍历，中途想要往集合中添加或删除元素，你要用迭代器自带的添加删除方法，就不会抛出异常。

    }
}

在这里插入图片描述

数据结构之栈和队列

数据结构概述及常见数据结构
数据结构其实就是存储数据的格式
分类: 栈 , 队列 , 数组 , 链表 , 树 , 哈希表图
栈特点: 先进后出弹夹
队列: 先进先出

数据结构之数组和链表

数组特点: 查询快 , 增删慢
链表特点: 查询慢 , 增删快

List的三个子类的特点

List的三个子类的特点
ArrayList:
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高
Vector:
底层数据结构是数组，查询快，增删慢。
线程安全，效率低
LinkedList:
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高
List有三个儿子，我们到底使用谁呢?
得看要安全还是要效率
是查找多还是增删多

ArrayList存储字符串并遍历

JDK1.8新增的一个方法也能遍历集合
void forEach(Consumer<? super E> action) 执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常

案例演示：ArrayList存储字符串并遍历
迭代器
普通for

package cn.itcast_01;
import java.util.ArrayList;
import java.util.Iterator
/*
 * List的子类特点:
 * 		ArrayList:
 * 			底层数据结构是数组,查询快,增删慢
 * 			线程不安全,效率高
 * 		Vector:
 * 			底层数据结构是数组,查询快,增删慢
 * 			线程安全,效率底
 * 		LinkedList:
 * 			底层数据结构是链表,查询慢,增删快
 * 			线程不安全,效率高	
 */
public class ArrayListDemo {
	public static void main(String[] args) {
		//创建集合对象
		ArrayList al = new ArrayList();
		//把字符串元素添加到集合对象中
		al.add("hello");
		al.add("world");
		al.add("java");
		//集合遍历
		Iterator it = al.iterator();
		while(it.hasNext()){
			String s = (String)it.next();
			System.out.println(s);
		}
		System.out.println("==============");
		for(int x = 0;x<al.size();x++){
			String s = (String) al.get(x);
			System.out.println(s);
		}
	}
}

在这里插入图片描述

package org.westos.demo;
import java.util.ArrayList;
import java.util.Iterator;
/*
 * ArrayList存储字符串并遍历。要求加入泛型，并用增强for遍历。
 * A:迭代器
 * B:普通for
 * C:增强for
 */
public class ArrayListDemo {
	public static void main(String[] args) {
		// 创建集合对象
		ArrayList<String> array = new ArrayList<String>();
		// 创建并添加元素
		array.add("hello");
		array.add("world");
		array.add("java");
		// 遍历集合
		// 迭代器
		Iterator<String> it = array.iterator();
		while (it.hasNext()) {
			String s = it.next();
			System.out.println(s);
		}
		System.out.println("========================================");
		// 普通for
		for (int x = 0; x < array.size(); x++) {
			String s = array.get(x);
			System.out.println(s);
		}
		System.out.println("===========================================");
		// 增强for
		for (String s : array) {
			System.out.println(s);
		}
	}
}

在这里插入图片描述

Vector的特有功能

Vector类概述：Vector类可以实现可增长的对象数组，Vector是同步的
Vector类特有功能
public void addElement(E obj) 添加指定的组件到这个向量的结束，增加其大小由一个
public E elementAt(int index) 返回索引的处的组件
public Enumeration elements() 返回此向量的组件的枚举
E firstElement() 返回此向量的第一个组件（位于索引 0) 处的项）
E lastElement() 返回此向量的最后一个组件。 void insertElementAt(E obj, int index) 将指定对象作为此向量中的组件插入到指定的 index 处。
案例演示：Vector的特有功能演示



package org.westos.demo2;
import java.util.Enumeration;
import java.util.Vector;
public class MyTest4 {
    public static void main(String[] args) {
       /* A:
        Vector类概述:
        java.util.Vector 类可以实现可增长的对象数组, Vector 是同步的。
        B:
        Vector类特有功能
        public void addElement (E obj)
        public E elementAt ( int index)
        public Enumeration elements ()
        E firstElement () 返回此向量的第一个组件（位于索引 0)处的项）。
        E lastElement () 返回此向量的最后一个组件。
        void insertElementAt (E obj,int index)将指定对象作为此向量中的组件插入到指定的 index 处。*/
        Vector vector = new Vector();
        vector.add(0, 200);
        vector.addElement(200);
        // Object o = vector.get(0);
        // Object o1 = vector.elementAt(2);
        Enumeration elements = vector.elements();
        while (elements.hasMoreElements()) {
            Object o = elements.nextElement();
            System.out.println(o);
        }
    }
}

在这里插入图片描述

LinkedList的特有功能

LinkedList类概述：List接口的链接列表实现，此实现不是同步的
LinkedList类特有功能
public void addFirst(E e) 在此列表的开始处插入指定元素
public void addLast(E e) 将指定的元素列表的结束
public E getFirst() 返回此列表中的第一个元素
public E getLast() 返回此列表中的最后一个元素
public E removeFirst() 移除并返回此列表中的第一个元素
public E removeLast() 移除并返回此列表中的最后一个元素
案例演示：LinkedList的特有功能演示

package org.westos.demo2;
import java.util.LinkedList;
public class MyTest5 {
    public static void main(String[] args) {
      /*  A:
        LinkedList类概述:
        List 接口的链接列表实现, 此实现不是同步的
        B:
        LinkedList类特有功能
        public void addFirst (E e)及addLast(E e)
        public E getFirst () 及getLast()
        public E removeFirst () 及public E removeLast()*/
        LinkedList linkedList = new LinkedList();
        linkedList.add(200);
        linkedList.addLast(61);
        linkedList.addLast(62);
        linkedList.addLast(63);
        linkedList.addLast(65);
        linkedList.addLast(60);
        // linkedList.addFirst(20);
        System.out.println(linkedList);
    }
}

在这里插入图片描述

用LinkedList模拟栈数据结构的集合并测试

案例演示：
需求：请用LinkedList模拟栈数据结构的集合，并测试

package org.westos.demo2;
import java.util.LinkedList;
public class MyList {
    private final LinkedList linkedList;
    public MyList() {
        //抽取成员变量  ctrl+alt+F
        linkedList = new LinkedList();
    }
    public void addEle(Object object) {
        linkedList.addFirst(object);
    }
    public Object getLastEle() {
        Object pop = linkedList.pop();
        linkedList.addLast(pop);
        return pop;
    }
}

测试类：

package org.westos.demo2;
import java.util.Stack;
public class MyTest {
    public static void main(String[] args) {
        /*A:
        案例演示:
        需求：请用LinkedList模拟栈数据结构的集合，并测试
            栈：先进的后出，后进的先出
        */
       /* ArrayList<Object> list = new ArrayList<>();
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        System.out.println(list);*/
        MyList myList = new MyList();
        myList.addEle(100);
        myList.addEle(200);
        myList.addEle(300);
        myList.addEle(400);
        Object lastEle = myList.getLastEle();
        System.out.println(lastEle);
        lastEle = myList.getLastEle();
        System.out.println(lastEle);
        lastEle = myList.getLastEle();
        System.out.println(lastEle);
        lastEle = myList.getLastEle();
        System.out.println(lastEle);
        Stack<Object> objects = new Stack<>();
    }
}

在这里插入图片描述

去除ArrayList中重复字符串元素方式

案例演示：
需求:ArrayList去除集合中字符串的重复值（字符串的内容相同）
思路：创建新集合方式

package org.westos.demo;
import java.util.ArrayList;
public class MyTest4 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        //去除重复元素
        System.out.println(list);
        //采用创建一个新容器
        ArrayList<Object> newList = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            String ele = (String) list.get(i);
            if (!newList.contains(ele)) {
                newList.add(ele);
            }
        }
        System.out.println(newList);
    }
}

在这里插入图片描述

去除ArrayList中重复自定义对象元素

案例演示：
需求：ArrayList去除集合中自定义对象元素的重复值（对象的成员变量值相同）
注意事项：重写equals()方法

package org.westos.demo3;
import org.westos.demo.Student;
import java.util.ArrayList;
public class MyTest5 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(new Student("张三", 23));
        list.add(new Student("张三", 23));
        list.add(new Student("李四", 24));
        list.add(new Student("李四", 24));
        list.add(new Student("王五", 25));
        list.add(new Student("赵六", 26));
        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);
            }
        }
        System.out.println(newList);
    }
}

package org.westos.demo3;
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 +
                '}';
    }
    @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);
    }
}

在这里插入图片描述

泛型概述和基本使用

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

package org.westos.demo3;
import java.util.ArrayList;
public class MyTest {
    public static void main(String[] args) {
        /*
        *  泛型机制：是一种把数据类型明确工作，推迟到创建对象或调用方法时，才去明确的一种机制。
        *  泛型的语法 <引用数据类型的代号> 例如 <E>  <T,R> <X>
          泛型：可以定义在 接口上，类上 方法上
           泛型，只在编译期有效，在运行期就擦除了
           使用泛型的好处：可以提高代码的扩展性，可以避免向下转型
        *
        * */
        ArrayList list = new ArrayList();
        list.add(200);
        list.add("abc");
        list.add(3.24);
        Object obj = list.get(0);
        //向下转型。
        Integer integer = (Integer) obj;
        //集合虽然说可以存储多中种引用数据类型，但是一般我们都会存储同一种数据类型。
        System.out.println("===============================");
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("abc");
        list1.add("bbb");
        //list1.add(100);
        String s = list1.get(0);
        System.out.println(s);
        System.out.println("===============================");
        ArrayList<Object> list2 = new ArrayList<>();
        list2.add(200);
        list2.add(5000);
        list2.add("Abc");
        Object o = list2.get(0);
        //JDK1.5之后 才引入的机制
    }
}

在这里插入图片描述

ArrayList存储字符串并遍历泛型版

案例演示：ArrayList存储字符串并遍历泛型版

「已注销」

关注

3
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
JavaSE--集合框架

Java--集合框架对象数组案例演示需求：我有3个学生，请把这3个学生的信息存储到数组中，并遍历数组，获取到每一个学生的信息学生：Student成员变量：name,age构造方法：无参，带参成员方法：getXxx()/setXxx()存储学生的数组集合集合的由来：面向对象语言对事物的体现都是以对象的形式，所以为了方便对象的操作，Java就提供了集合类数组和集合的区别a.长度区别：数组的长度是固定的而集合的长度是可变的b.存储数据类型的区别数组可以存储基本类型，也可以
复制链接

扫一扫

专栏目录