集合Collection2019-08-16

目的：

学习Collection接口的方法与使用，以及Collection抽象接口的子类List的ArrayList类的方法。

技术：

1.调用Collection接口的前提：

数组: 存储多个对象
int[] score = {1,2,3};
int[] score = int int[10];
弊端：数组长度不可变 内容可变

实际开发中需要一个能够随时改变的数组->集合Collection

 * Collection抽象接口 定义集合的相关操作
 *         |--List接口 列表 数组  特点：有序  重复
 *               |--ArrayList
 *               |--LinkedArrayList
 *         |--Set“集合” 特点：
 *               |--HasSet
 * Map接口  映射关系  Key-Value  键值对  健不能相同，值可以相同
 *         |--HashMap
 *         语文 98
 *         英语 98
 *
 * Collections类
 *
 * 集合的元素是可变的
 * 添加元素 : add addAll
 * 删除元素
 * 插入元素
 * 访问元素

2.Cllection接口的调用：

添加 删除 获取

      //Collection接口
        Collection<String> text = new ArrayList<>();
        text.add("Jack");
        text.add("Merry");
        System.out.println(text);

        //删除一个对象
        text.remove("Jack");
        System.out.println(text);

        //获取元素个数
        System.out.println(text.size());

判断是否包含一个元素

        if(text.contains("Merry")){
            System.out.println("有Merry");
        }else{
            System.out.println("无Merry");
        }

        //判断是否为空
        if(text.isEmpty()){
            System.out.println("是空的");
        }

判断两个集合是否相同 (equals比较集合的内容)

        Collection<String> text2 = new ArrayList<>();
        text2.add("Merry");
        text2.add("Jack");

        if(text.equals(text2)){
            System.out.println("两个集合相同");
        }else{
            System.out.println("两个集合不相同");
        }

清空

        text.clear();
        System.out.println(text);

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

重点 集合的遍历 遍历过程中不要进行插入删除方法
1.使用Iterator遍历
hasNext 判断是否有元
next 获取下一个元素
remove 删除当前遍历过后的对象


        Iterator iterator = text2.iterator();

        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("----------------");

        //2. for-each 增强的for循环 快速循环
        for(String obj :text2){
            System.out.println(obj);
        }

        System.out.println("----------------");
        //3.for-i
        for(int i = 0; i < text2.size(); i++){
            System.out.println(((ArrayList<String>) text2).get(i));
        }

3.List类的学习与使用：

List接口 extends Collection
1.ArrayList
2.LinkedArrayList 内部使用链表实现
ArrayList连续的内存空间 优点：访问方便 缺点：删除 添加
LinkedArrayList 链表不一定连续（基本不连续） 优点：增加 删除 缺点：访问
集合里面只能存放对象
byte char long int float double boolean ArrayList<>括号里面不能是基本数据类型
包装类
Byte Char Int Long Float Double Boolean
自动将基本数据类型转化为对于包装类

添加 访问 修改 插入

ArrayList<Integer> score = new ArrayList<>();
        score.add(2);        //在末尾添加
        score.add(3);
        
        score.add(0,1);//在指定位置插入
        System.out.println(score);

        //访问指定元素
        score.get(1);

        //修改一个元素
        score.set(2,4);

删除

        //删除指定元素
        score.remove(0);
        System.out.println(score);

        //删除指定对象
        score.remove((Integer)2);
        System.out.println(score);

        score.clear();//删除所有 清空
        System.out.println(score);

        ArrayList<Integer> a2 = new ArrayList<>();
        a2.add(5);
        a2.add(6);
        a2.add(7);

将一个集合的内容添加到当前集合中 取交集

        score.addAll(a2);
        System.out.println(score);

        ArrayList<Integer> a3 = new ArrayList<>();
        a3.add(1);
        a3.add(2);
        a3.add(3);
        a3.add(4);
        a3.add(5);
        score.retainAll(a3); //取交集
        System.out.println(score);

访问某个集合里面元素的位置/索引值

        ArrayList<Integer> a4 = new ArrayList<>();
        a4.add(1);
        a4.add(2);
        a4.add(2);
        a4.add(1);

        System.out.println(a4.indexOf(1));//第一次出现的位置
        System.out.println(a4.lastIndexOf(1));//最后一次出现的位置

将ArrayList转化为普通数组

        //1.
        Object[] objects = a4.toArray();//为什么这么做:让a4转为不可变的
        for(Object i:objects){
            System.out.println(i);
        }
        System.out.println("-------------------");
        //2.
        Integer[] objects2 = new Integer[a4.size()];
        a4.toArray(objects2);
        for(Integer i:objects2){
            System.out.println(i);
        }

获取集合某个范围的子集合

        List<Integer> intederList =  a4.subList(1,3); // 1到2，不包括3所对应的元素
        System.out.println(intederList);

删除某个范围内的元素


        ArrayList<Integer> nums = new ArrayList<>();
        nums.add(1);
        nums.add(2);
        nums.add(3);
        nums.add(4);

        //Lambda表达式
        nums.removeIf(obj -> obj % 2 == 0);

        System.out.println(nums);
        // or

        for(int i = 0; i < nums.size(); i++){
            Integer obj = nums.get(i);
            if(obj % 2 == 0){
                nums.remove(i);
                  i--;
            }
        }
        System.out.println(nums);
闭包：

闭包 enclusure 把函数作为一个方法的参数
定义一个ArrayClass类，其中定义一个方法，方法参数为一个整形数组和一个接口对象

class ArrayClass{
    public void test(int[] target, Show s){
        for (int element: target){
            s.customShow(element);
        }
    }
}

//必须是接口 这个接口里面只有一个方法
interface Show{
    void customShow(int element);
}

class PXDClass implements Show{
    @Override
    public void customShow(int element) {
        System.out.println(element);
    }
}

调用：
1.使用方式: 定义一个类实现接口

       
        ArrayClass ac = new ArrayClass();
        int[] num = {1,2,3,4,5,6};
        PXDClass pc = new PXDClass();
        ac.test(num, pc);

2.使用匿名类

        ArrayClass ac = new ArrayClass();
        int[] num = {1,2,3,4,5,6};
        ac.test(num, new Show() {
            @Override
            public void customShow(int element) {
                System.out.println(element);
            }
        });
  1. 使用Lambda表达式
        //如果参数是一个接口类对象，且接口里面只有一个方法
        //把这个方法作为参数传递过去 可以省略方法名
        ArrayClass ac = new ArrayClass();
        int[] num = {1,2,3,4,5,6};
        ac.test(num, (int element) -> {
            System.out.println(element);
        });

4.如果只有一个参数 参数类型可以省略

        ArrayClass ac = new ArrayClass();
        int[] num = {1,2,3,4,5,6};
        ac.test(num,element -> {
            System.out.println(element);
        });

5.如果代码块里面只有一行语句 大括号可以省略

        ArrayClass ac = new ArrayClass();
        int[] num = {1,2,3,4,5,6};
        ac.test(num,element -> System.out.println(element));
排序 sort：
1.对整形数组排序：
//排序 sort
          ArrayList<Integer> a1 = new ArrayList<>();
          a1.add(2);
          a1.add(1);
          a1.add(4);
          a1.add(3);

//          //方法1.系统提供
//          a1.sort(Comparator.comparing(Integer::intValue));

//        //方法2.
//        a1.sort( new PXDCompara());

//        //方法3匿名
//        a1.sort(new Comparator<Integer>() {
//            @Override
//            public int compare(Integer integer, Integer t1) {
//                return integer - t1;
//            }
//        });

//        //方法4.化简
//        a1.sort((Integer integer, Integer t1)->{
//            return integer - t1;
//        });
        System.out.println(a1);

方法2的PSDCompare类：

class PXDCompara implements Comparator{
    //什么时候需要自己手动创建比较器
    //如果系统默认提供的方法不能完成我们的需求
    @Override
    public int compare(Object o, Object t1) {
        int mo = (int)0;
        int mt1 = (int)t1;
        return mo - mt1;
    }
}
2.对象排序：
//对象排序
        List<Person> list = new ArrayList<>();

        Person person1 = new Person("jack",20);
        Person person2 = new Person("rose",30);
        Person person3 = new Person("jack",30);

        list.add(person1);
        list.add(person2);
        list.add(person3);


        //进行排序
        //系统提供 按年龄排序
        //list.sort(Comparator.comparing(Person::getAge));

        //自己编写 先按年龄 再比姓名
        list.sort((Person p1 , Person p2) -> {
            if(p1.getAge()  != p2.getAge()){
                return p1.getAge() - p2.getAge();
            }else{
                return p1.getName().compareTo(p2.getName());
            }
        });
        System.out.println(list);

提供的·Person类：

class Person {
    public String name;
    public int age;

    public Person(String name, int age){
        this.age = age;
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

实际编程：

编程一：

  • 创建一个Person: name age属性
  • 创建ArrayList对象保存多个Person对象
  • 1.统计年龄大于30的人数
  • 2.统计姓张的人数
1.定义Person类：
public class Person {
    public String name;
    public int age;

    public Person(String name, int age){
        this.age = age;
        this.name = name;
    }
}
2.进行操作：
import java.util.ArrayList;

public class Myclass {
   public static void main(String[] args){
       ArrayList<Person> people = new ArrayList<>();

       Person person1 = new Person("wuxia",18);
       Person person2 = new Person("liyuan",30);
       Person person3 = new Person("wangwu",21);
       Person person4 = new Person("lisi",34);
       Person person5 = new Person("zhangsan",25);

/*

       people.add(person1);
       people.add(person2);
       people.add(person3);
       people.add(person4);
       people.add(person5);

       int countA = 0;

       people.removeIf(obj -> obj.age < 30);
       for(Person person : people){
           countA++;
       }
       System.out.println(countA);

       people.clear();

       people.add(person1);
       people.add(person2);
       people.add(person3);
       people.add(person4);
       people.add(person5);

       int countB = 0;
       int count = people.size();

       people.removeIf(obj -> obj.name.contains("zhang"));
       for(Person person : people){
           countB++;
       }
       System.out.println(count-countB);

*/
       people.add(person1);
       people.add(person2);
       people.add(person3);
       people.add(person4);
       people.add(person5);

       int ageCount = 0;
       int zhangCount = 0;

       for(Person person : people){
           if(person.age >= 30){
               ageCount++;
           }
           if(person.name.contains("zhang")){
               zhangCount++;
           }
       }
      System.out.println(ageCount);
      System.out.println(zhangCount);
   }
}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

相关阅读更多精彩内容

友情链接更多精彩内容