15-java学习-对象数组、集合、数据结构-案例代码

15-java学习-对象数组、集合、数据结构-案例代码

1.需求：我有3个学生，请把这个3个学生的信息存储到数组中，并遍历数组，获取得到每一个学生信息。

public class MyTest2 {
    public static void main(String[] args) {
        Student s1 = new Student("张三", 23);
        Student s2 = new Student("李四", 24);
        Student s3 = new Student("王五", 25);

        //容器：数组  StringBuffer
        Student[] students=new Student[3];  //对象数组
        students[0]=s1;
        students[1] = s2;
        students[2] = s3;

        //遍历
        for (int i = 0; i < students.length; i++) {
            Student student = students[i];
            System.out.println(student.getName()+"==="+student.getAge());
        }

        //数组作为容器，有一些不方便之处
        //数组一旦定义长度就固定了，我不好在数组中进行增删元素
        //数组作为容器，不方便你去操作容器中的元素，比如增和删
        //Java也考虑到这一点，给我们提供了另外一种容器，叫做集合，可以很方便的对容器中的元素，进行增删改查
        //数组和集合的区别
        //1.数组一旦定义，长度就不可变了 集合的长度是可变的
        //2.数组既可以存储基本类型数据，也可以存储 引用类型的数据，集合只能存储引用类型的数据
        //3.数组只能存储同一种类型的数据，集合可以存储多种类型的数据

    }
}

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 +
                '}';
    }
}

2. Collection 集合体现，集合有很多种，每种集合有各自的特点

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

public class MyTest {
    public static void main(String[] args) {
        //多态
     Collection collection= new ArrayList();
     //往集合中添加元素
     collection.add("张三");
        collection.add("李四");
        collection.add("王五");

        System.out.println(collection);
    }
}

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

public class MyTest2 {
    public static void main(String[] args) {
        Student s1 = new Student("张三", 23);
        Student s2 = new Student("李四", 24);
        Student s3 = new Student("王五", 25);
        Collection arrayList = new ArrayList();
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);

        System.out.println(arrayList);
    }
}

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

public class MyTest3 {
    public static void main(String[] args) {

        Collection arrayList = new ArrayList();
        arrayList.add(100);
        arrayList.add(200);
        arrayList.add(new Integer(300));

        System.out.println(args);

        Collection arrayList2 = new ArrayList();
        arrayList2.add(1000);
        arrayList2.add(2000);
        arrayList2.add(3000);
        //addAll() 把两个集合的元素放到一个集合中,返回值是有没有添加成功

        boolean b = arrayList.addAll(arrayList2);

        System.out.println(arrayList);

        System.out.println(arrayList2);

        //删除集合中的元素
        boolean remove = arrayList.remove(100);
        System.out.println(arrayList);

        //清空集合中的所有元素

        arrayList.clear();

        System.out.println(arrayList);


    }
}

5.boolean removeAll (Collection c):移除一个集合的元素(移除一个以上返回的就是true) 删除的元素是两个集合的交集元素,如果没有交集元素 则删除失败 返回false

public class MyTest4 {
    public static void main(String[] args) {
        Collection arrayList = new ArrayList();
        arrayList.add(1000);
        arrayList.add(2000);
        arrayList.add(3000);

        Collection arrayList2 = new ArrayList();
        arrayList2.add(1000);
        arrayList2.add(2000);
        arrayList2.add(3000);

        //A集合.removeAll(B集合); A集合中会移除掉两个集合的交集元素，如果没有交集元素，则移除失败返回false
        boolean b = arrayList.removeAll(arrayList2);
        System.out.println(b);
        System.out.println(arrayList);
        System.out.println(arrayList2);
    }
}

6.判断集合中有没有这个元素,判断和集合是否为空

public class MyTest5{
    public static void main(String[] args) {

        Collection arrayList = new ArrayList();
        arrayList.add(1000);
        arrayList.add(2000);
        arrayList.add(3000);
        //判断集合中有没有这个元素
        boolean contains = arrayList.contains(10000);
        System.out.println(contains);

        //判断和集合是否为空
        boolean empty = arrayList.isEmpty();
        System.out.println(empty);

    }
}

7.A集合containsAll(B集合) B集合中的所有元素，在A集合中都能找到，那就返回true,否则返回false

public class MyTest6 {
    public static void main(String[] args) {
        Collection arrayList = new ArrayList();
        arrayList.add(1000);
        arrayList.add(2000);
        arrayList.add(3000);
        arrayList.add(4000);
        arrayList.add(5000);
        arrayList.add(6000);

        Collection arrayList2 = new ArrayList();
        arrayList2.add(1000);
        arrayList2.add(2000);
        arrayList2.add(3000);

        arrayList2.add(4000);
        arrayList2.add(400);

        //A集合containsAll(B集合)  B集合中的所有元素，在A集合中都能找到，那就返回true,否则返回false
        boolean b = arrayList.containsAll(arrayList2);
        System.out.println(b);
    }
}

8.

public class MyTest7 {
    public static void main(String[] args) {
        Collection arrayList = new ArrayList();
        arrayList.add(1000);
        arrayList.add(2000);
        arrayList.add(3000);
        arrayList.add(4000);
        arrayList.add(5000);
        arrayList.add(6000);
        //获取集合中的元素的个数
        int size = arrayList.size();
        System.out.println(size);

        Iterator iterator = arrayList.iterator();
        System.out.println(iterator);
        // iterator.next();
        while (iterator.hasNext()){ //判断是否还有下一个元素
            Object next = iterator.next(); //把指针狭义
            System.out.println(next); //获取下一个元素
        }
    }
}

9.A集合对B集合取交集，获取到的交集元素在A集合中。返回的布尔值表示的是A集合是否发生变化

public class MyTest8 {
    public static void main(String[] args) {
        Collection arrayList = new ArrayList();
        arrayList.add(1000);
        arrayList.add(2000);
        arrayList.add(3000);
        arrayList.add(4000);
        arrayList.add(5000);
        arrayList.add(6000);
        arrayList.add(10);

        Collection arrayList2 = new ArrayList();
        arrayList2.add(1000);
        arrayList2.add(2000);
        arrayList2.add(3000);
        arrayList2.add(4000);
        arrayList2.add(5000);
        arrayList2.add(6000);
        arrayList2.add(8000);
//A集合对B集合取交集，获取到的交集元素在A集合中。返回的布尔值表示的是A集合是否发生变化
        boolean b = arrayList.retainAll(arrayList2);
        System.out.println(b);
        System.out.println(arrayList);
        System.out.println(arrayList2);
    }
}

10.使用for循环遍历

public class MyTest9 {
    public static void main(String[] args) {
        Collection arrayList = new ArrayList();
        arrayList.add(1000);
        arrayList.add(2000);
        arrayList.add(400);
        arrayList.add(30000);
        arrayList.add(5000);
        arrayList.add(6000);
        //把集合转换成数组

        //把一个集合转换成数组
       Object[] objects =  arrayList.toArray();

        System.out.println(Arrays.toString(objects));

        for (int i = 0; i < objects.length; i++) {
            Object object = objects[i];
            Integer num= (Integer) object;
            System.out.println(num);
        }
    }
}

11.遍历集合打印学生信息

public class MyTest91 {
    public static void main(String[] args) {
        Student s1 = new Student("张三", 23);
        Student s2 = new Student("李四", 24);
        Student s3 = new Student("王五", 25);
        Collection arrayList = new ArrayList();
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        //遍历集合打印学生信息
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()){
            Object obj = iterator.next();
            //向下转型
            Student student= (Student) obj;
            System.out.println(student.getName()+"==="+student.getAge());

        }
    }
}

12.List 接口中的方法

public class MyTest {
    public static void main(String[] args) {
        List arrayList = new ArrayList();

        arrayList.add(100);
        arrayList.add(100);
        arrayList.add(100);
        arrayList.add(100);
        //在指定的索引处，添加元素
        arrayList.add(0,200);
        arrayList.add(1,300);

        System.out.println(arrayList);
        System.out.println(arrayList.indexOf(1000));
        //通过起始索引和终止索引，从集合中截取某些元素，放到一个新集合中
        List list = arrayList.subList(0, 3);
        System.out.println(list);
        System.out.println(arrayList);

        //通过索引获取某个元素
        Object o = arrayList.get(0);
        System.out.println(o);
        //通过索引替换集合中的元素 set() 返回的是被替换的旧元素

        Object o1 = arrayList.set(0, 2000);
        System.out.println(o1);
        System.out.println(arrayList);
    }
}

13.遍历List集合

public class MyTest2 {
    public static void main(String[] args) {
        List arrayList = new ArrayList();

        arrayList.add(1001);
        arrayList.add(1002);
        arrayList.add(1003);
        arrayList.add(1004);
        //方式1 迭代器
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }
        System.out.println("=========================");
        //方式2：for 推荐
        for (int i = 0; i < arrayList.size(); i++) {
            Object o = arrayList.get(i);
            System.out.println(o);
        }
        System.out.println("=======================");

        //方式3 List 集合自己的迭代器
        ListIterator listIterator = arrayList.listIterator();

        //java.util.ArrayList$ListItr
        System.out.println(listIterator);

        while (listIterator.hasNext()){
            Object next = listIterator.next();
            System.out.println(next);
        }
    }
}

14.正向迭代、反向迭代

public class MyTest3 {
    public static void main(String[] args) {
        List arrayList = new ArrayList();

        arrayList.add(1001);
        arrayList.add(1002);
        arrayList.add(1003);
        arrayList.add(1004);

        //正向迭代
        ListIterator listIterator = arrayList.listIterator();
        while (listIterator.hasNext()){
            Object next = listIterator.next();
            System.out.println(next);
        }
        System.out.println("===================");
        //反向迭代：注意进行反向迭代器前，先进行正向迭代
       // ListIterator listIterator2 = arrayList.listIterator();
        while (listIterator.hasPrevious()){ //判断有没有上一个元素
            Object previous = listIterator.previous(); //获取上一个元素
            System.out.println(previous);
        }
    }
}

15.需求：有一个集合，判断里面有没有 “world” 这个元素，如果有，就添加一个 “javaee” 元素

public class MyTest4 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("world");
        list.add("ddd");

        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()){
            Object obj = listIterator.next();
            String str= (String) obj;
            if(str.equals("world")){
                //方式1：你用迭代器遍历，在遍历的途中想要给集合中添加元素或删除元素，请使用迭代器自带的添加或删除元素的方法
                listIterator.add("javaee");
            }
        }

        System.out.println(list);


        System.out.println("==================================");
        for (int i = 0; i < list.size(); i++) {
            Object obj = list.get(i);
            String str = (String) obj;
            if (str.equals("world")) {
                list.add("php");
            }
        }
        System.out.println(list);
    }
}