onlyxue

  博客园  :: 首页  :: 新随笔  :: 联系 :: 订阅 订阅  :: 管理
java_day12~13

Java基础

Java集合框架

什么是集合？

​ 对象的容器，定义了对多个对象进程操作的常用方法。可实现数组的功能。

与数组的区别是什么？

1. 数组长度固定，集合长度是不固定
1. 数组可以存储基本类型和引用类型，而集合只能存储引用类型

Collection体系集合

​ Collection ----Interface

​ List Set ----Interface

​ ArrayList LinkedList Vector HashSet SortedSet ----Class

​ TreeSet ----Class

​ Collection是此体系结构的根接口，代表一组对象，称为集合

​ List接口的特点是 有序、有下标、元素可以重复可以重复可以重复

​ Set接口的特点是 无序、无下标、元素不可重复不可重复不可重复

  • Collection父接口

    • 特点：代表一组任意类型的对象，无序、无下标、不能重复
    public class Demo1 {

    //Collection接口的使用

    public static void main(String[] args) {

        //创建一个集合
        Collection col = new ArrayList();

        //添加元素
         col.add("apple");
         col.add("watermelon");
         col.add("bannana");
         col.add("pear");
        System.out.println("元素个数:"+ col.size());
        System.out.println(col);

        //删除元素
        col.remove("bannana");
        System.out.println("删除后元素个数:"+ col.size());
//        col.clear();//清空元素

        //遍历元素
        for (Object obj:col) {
            System.out.println(obj);
        }

        System.out.println("=================");

        Iterator it = col.iterator();//使用迭代器遍历集合
        /*
            迭代器是专门用来遍历的一种方式
            hasNext() 判断有无下一个元素
            next() 获取下一个元素
            remove() 删除当前元素
         */

        while (it.hasNext()){

                System.out.println(it.next());
//                it.remove();

        }
//        System.out.println(col.size());

        //判断
        System.out.println(col.contains("pear"));//判断是否包含pear
        System.out.println(col.isEmpty());//判断是否为空

    }
}

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 class TestStudent {
    public static void main(String[] args) {
        Student stu1 = new Student("zhangsan",18);
        Student stu2 = new Student("lisi",19);
        Student stu3 = new Student("wangwu",20);
        Student stu4 = new Student("laoliu",25);


        Collection col = new ArrayList();

        //添加student对象至集合中
        col.add(stu1);
        col.add(stu2);
        col.add(stu3);
        col.add(stu4);

        System.out.println("元素个数："+col.size());
        System.out.println(col);//这里还是会调用重写的toString方法

        //删除元素
        System.out.println("由于张三太狂了要开除");
        col.remove(stu1);
        System.out.println(col.size());
        System.out.println(col.toString());//这里可以法toString是灰色的意味这即使不写也会隐式调用

        //遍历
        System.out.println("++++++++++++++++++++++");
        for (Object x:col){
            System.out.println(x);   //这里同样会调用Student的toString方法
        }


        System.out.println("==========================");
        Iterator it = col.iterator();
        while (it.hasNext()){
            //同理 next()返回的是Object类上上面一致
            System.out.println(it.next());
        }

        //判断
        System.out.println(col.isEmpty());
        System.out.println(col.contains("张三"));

    }
}

List子接口

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

  • 方法：add、allAll、get、subList、

    public class Demo1 {
    public static void main(String[] args) {
        //创建List集合
        List list = new ArrayList<>();

        //添加元素
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add(1,"d");
        System.out.println("元素个数："+list.size());
        System.out.println(list.toString());

        //删除
        list.remove("d");//删除顺序靠前的元素d
        list.remove("d");
        list.remove(1);//删除序列为1的元素
        System.out.println("删除后元素个数："+list.size());
        System.out.println(list.toString());

        System.out.println("========================");

        //遍历
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        System.out.println("foreach");
        for (Object obj : list) {
            System.out.println(obj);
        }

        System.out.println("Iterator");
        Iterator it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

        System.out.println("ListIterator顺序");
        ListIterator it2 = list.listIterator();
        while (it2.hasNext()){
            System.out.println(it2.nextIndex()+":"+it2.next());
        }

        System.out.println("ListIterator反序");
        //一定要先进行由前向后输出，之后才能进行由后向前的输出,所以这里的新迭代器直接反序什么都输出不了
        ListIterator it3 = list.listIterator();
        while (it2.hasPrevious()){
            System.out.println(it2.previousIndex()+":"+it2.previous());
        }

        //判断
        System.out.println(list.contains("a"));//是否存在元素a
        System.out.println(list.isEmpty());//是否为空

        //获取元素位置
        System.out.println(list.indexOf("a"));

    }
    
    public class Demo2 {
    public static void main(String[] args) {
        //创建集合
        List list = new ArrayList();
        //添加数字类型数字会自动装箱
        list.add(23);
        list.add(23.23);
        list.add(2345);
        list.add(234.3453);
        list.add(342.2);
        System.out.println(""+list.size());
        System.out.println(list);

        //删除
//        list.remove(1);
//        list.remove((Object)23);
//        list.remove(new Integer(23));
        //上面三种结果一致

        List list2 = list.subList(1,4);//含左不含右
        System.out.println(list2);
    }
}

List实现类

  • （重点）ArrayList:数组结构实现，查询快，增删慢；运行快，线程不安全
  • Vector:查询快，增删慢；运行慢、线程安全
  • LinkedList:链表结构，增删快，查询慢

ArrayList

ArrayList 的实现原理：类中有DEFAULT_CAPACITY = 10;默认容量

类中还有一个数组对象elementData是用于存放元素的

Size 用于计算实际元素的个数，而add方法则用于添加元素

新创建一个空的ArrayList对象是容量为0，但是一旦再新的集合对象中添加一个元素时，容量0就变成了10，每当容量用完再一次添加元素时 容量会扩容至1.5倍

@Override //重写的equals方法
public boolean equals(Object obj) {
    if (this==obj){
        return true;
    }
    if (obj == null){
        return false;
    }
    if (obj instanceof Student){
        Student stu = (Student) obj;
        if (this.name.equals(stu.getName())&&this.age==stu.getAge()){
            return true;
        }
    }
    return false;
}

public class Demo3 {
    public static void main(String[] args) {
        //创建ArrayList集合
        ArrayList alist = new ArrayList();
        //创建Studnet实例对象
        Student stu1 = new Student("zhangsan",20);
        Student stu2 = new Student("lisi",23);
        Student stu3 = new Student("wangwu",45);
        Student stu4 = new Student("zhaoliu",34);

        //添加对象至集合中
        alist.add(stu1);
        alist.add(stu2);
        alist.add(stu3);
        alist.add(stu4);

        System.out.println("元素个数为："+alist.size());
        System.out.println(alist.toString());//toString为灰色 隐式调用stdent类重写方法toString

        //删除集合
//        alist.remove(0);
//        alist.remove(stu2);
        //remove方法调用的是equals方法 重写后可以实现创建对象比较值删除对应集合中的元素
        alist.remove(new Student("wangwu",45));


        System.out.println("删除后元素个数为："+alist.size());
        System.out.println(alist);

        //遍历集合
        System.out.println("for");
        for (int i = 0; i < alist.size(); i++) {
            System.out.println(alist.get(i).toString());
        }

        System.out.println("foreach");
        for (Object obj : alist){
            System.out.println(obj.toString());
        }

        System.out.println("Iterator");
        Iterator it = alist.iterator();
        while (it.hasNext()){
            System.out.println(it.next().toString());
        }

        System.out.println("ListIterator");
        ListIterator lit = alist.listIterator();
        while (lit.hasNext()){
            System.out.println(lit.nextIndex()+":"+lit.next().toString());
        }

        System.out.println("ListIterator逆序");
        while (lit.hasPrevious()){
            System.out.println(lit.previousIndex()+":"+lit.previous());
        }
    }


}

Vector

  • 数据结构，查询快、增删慢

  • 运行效率慢、线程安全

  • 此类使用不多

/**
 * @author xue
 * vector的使用
 * vector向量的意思
 * 此实现类用的不多 了解
 */
public class Demo4 {
    public static void main(String[] args) {
        //创建vector集合
        Vector vec1 = new Vector();

        //创建Studnet实例对象
        Student stu1 = new Student("zhangsan",20);
        Student stu2 = new Student("lisi",23);
        Student stu3 = new Student("wangwu",45);

        //添加元素
        vec1.add(stu1);
        vec1.add(stu2);
        vec1.add(stu3);

        System.out.println("元素个数："+vec1.size());

        //删除与arraylist一致
//        vec1.remove(0);
//        vec1.remove(stu2);
//        vec1.clear();//清空集合

        //遍历
        System.out.println("枚举遍历");
        Enumeration en = vec1.elements();
        while (en.hasMoreElements()){

            Student stu = (Student) en.nextElement();
            System.out.println(stu);
        }

        System.out.println("for循环遍历");
        for (Object obj : vec1){
            System.out.println(obj);
        }

        System.out.println("迭代器遍历");
        Iterator it = vec1.iterator();
        while (it.hasNext()) {
            Student stu = (Student) it.next();
            System.out.println(stu);
        }

        //判断
        System.out.println(vec1.contains(stu1));
        System.out.println(vec1.isEmpty());
        System.out.println(vec1.firstElement());//获取第一个元素
        System.out.println(vec1.lastElement());//获取最后一个元素
        System.out.println(vec1.elementAt(1));//获取某位置的元素


    }
}

LinkedList

  • 链表结构，增删快、查询慢

  • 常用

    /**
 * LinkedList的使用
 * 存储结构：双向链表
 * @author xue
 */
public class Demo5 {
    public static void main(String[] args) {
        //创建LinkedList集合
        LinkedList llist = new LinkedList();

        //添加元素
        Student stu1 = new Student("zhangsan",20);
        Student stu2 = new Student("lisi",23);
        Student stu3 = new Student("wangwu",45);
        llist.add(stu1);
        llist.add(stu2);
        llist.add(stu3);
        llist.add(stu3);

        System.out.println("元素个数："+llist.size());
        System.out.println(llist); //隐式toString方法

        //删除元素
        llist.remove(stu3);//equals已被重写 这里new一个对象值与元素一致可以被删除
        System.out.println("删除后元素个数："+llist.size());
        System.out.println(llist); //隐式toString方法

        //遍历
        System.out.println("for遍历");
        for (int i=0;i< llist.size();i++) {
            System.out.println(llist.get(i));
        }

        System.out.println("foreach遍历");
        for (Object s : llist) {
            //这里的类型我就不向下转型了
            //Student stu = (Student)s;
            System.out.println(s);
        }

        System.out.println("Iterator遍历");
        Iterator it = llist.iterator();
        while (it.hasNext()) {
            //只是打印可以不强制转换类型 但是如果使用对象的方法就需要了
            System.out.println(it.next());
        }

        System.out.println("listIterator遍历");
        ListIterator lit = llist.listIterator();
        while (lit.hasNext()) {
            //只是打印可以不强制转换类型 但是如果使用对象的方法就需要了
            System.out.println(lit.nextIndex()+":"+lit.next());
        }

        System.out.println("listIterator遍历逆序");
        while (lit.hasPrevious()) {
            //只是打印可以不强制转换类型 但是如果使用对象的方法就需要了
            System.out.println(lit.previousIndex()+":"+lit.previous());
        }

        //判断
        System.out.println(llist.contains(stu1));
        System.out.println(llist.isEmpty());
        System.out.println(llist.get(2));
        System.out.println(llist.indexOf(stu3));

    }
}

​ 建议把数据结构中的链表结构看一下 才能掌握LinkedList的原理

posted on 2022-10-14 15:11  守望在路上  阅读(23)  评论(0)    收藏  举报