Java基础（7）——集合和Map

本节内容

1.ArrayList基本使用

2.Map使用

3.联系人项目任务布置

一、ArrayList基本使用

（1）.Collection 是集合类的一个接口，定义了集合共有的方法

（2）.Collection接口以下有两个子接口：List和Set。①List：列表（数组），允许有重复的对象，并且是有序的。②Set：集合（和数学概念里的集合意义相同），没有顺序且不能包含重复对象 注：List与Set的使用方法相同，它们唯一的不同就是前面介绍的

（3）.List接口又有两个子类：ArrayList类和LinkedList类。①ArrayList：实现类 ，内部是线性表结构，当频繁使用get时使用 ②LinkedList类：实现类，内部使用链表结构，当频繁出现add和remove时使用

• 1.创建一个List类，其实ArrayList和LinkedList的调用方法相同，以下以ArrayList类为例。其中<>里面是数组类型，因为List是接口，不能被实例化，所以创建的是子类的对象，这就是多态。

       List<Person> people =new ArrayList();
        ArrayList<Person> people1=new ArrayList<>();

• 2.添加对象时，因为只添加一次，所以没有必要重新创建一个Person类对象，再将其传给数组，直接使用匿名对象即可。调用add函数添加对象时，如果调用的是含有一个参数的add函数，那么就是默认在数组末尾添加对象。

 //数组的创建
        //集合对象里面只能保存同一种数据类型
        List<Person> people =new ArrayList();
        ArrayList<Person> people1=new ArrayList<>();

        //添加对象,在数组末尾添加
        people1.add(new Person(35,98,"Jack"));
        people1.add(new Person(33,78,"Rose"));
        people1.add(new Person(23,88,"Lucy"));

• 3.插入数据，同样调用add函数，不过是调用有两个参数的add函数，前面的表示插入的位置，后面的表示要插入的对象。也可以调用addAll函数插入多个数据

       //在某个位置插入数据
        people1.add(0,new Person(23,58,"Merry"));

• 5.获取一个对象，直接用get方法访问

        //获取一个对象
        Person person= people1.get(0);

• 4.遍历一个数组，有三种方法

• ①使用for循环遍历，可以调用.size()函数获取数组的大小

     //1.使用for循环遍历
        for (int i=0;i<people1.size();i++){
            Person p=people1.get(i);
            System.out.println(p);
        }

• ②使用增强for循环遍历

    //2.使用增强for循环遍历
        for(Person p:people1){
            System.out.println(p);
        }

• ③使用Iterator遍历器来遍历

       Iterator<Person> interator= people1.iterator();
         //使用hasNext（） 判断是否还有下一个
        //next（）获取下一个对象
        while (interator.hasNext()){
            Person p=interator.next();
            System.out.println(p);
        }

• 5.删除某个对象，调用remove方法，如果是删除i对应的对象，那么直接调用参数类型为int的remove函数。如果删除的是某个对象，那么就调用参数类型为Object的remove函数

           //删除i对应的对象
            people1.remove(i);
            //删除某个对象
            people1.remove(p);

如果是在for循环里面通过i来删除数组，那么删除以后i++，然后数组对象又会重新编号（从0往后），所以可能删除的不完整，那么用for循环来删除数组就有点不靠谱

• 6.(iterator)来删除数组，就可以把里面的元素全部删除

     while (interator.hasNext()){
            interator.remove();
        }

• 7.按照一定的条件删除：①.创建predicate的子类对象，首先写一个Mypredicate类，在里面写上我们删除的条件，可以按照这个条件来删除

 static class Mypredicate implements Predicate<Person>{
        public boolean test(Person person){
            if(person.age>30){
                return true;
            }
            return false;
        }
    }

然后在主类里面定义一个Mypredicate类，再用数组调用removeIf方法

     //数据的删除
      Mypredicate mypredicate=new Mypredicate();
        people1.removeIf(mypredicate);

②.使用匿名内部类,这样就不用再另外创建一个类了

people1.removeIf(new java.util.function.Predicate<Person>() {
           @Override
           public boolean test(Person person) {
               if(person.age>30){
                   //如果返回值为true，那么这个对象将会被删除
                   return true;
               }
               return false;
           }
       });

• 8.数组的排序：①、自己定义的类必须实现Comparable接口和CompareTo方法，以下代码我只添加了CompareTo方法，其他的属性没有写出来，这是升序排序，如果想要实现降序排序，只需将1和-1的位置互换即可

class Person implements Comparable<Person> {
@Override
    public int compareTo(Person person) {
        if(person.age>this.age){
            return 1;
        }else if(person.age==this.age){
            return 0;
        }
        return -1;
    }
}

然后在子类里面通过Collection调用sort方法

Collections.sort(people1);

数组的排序：②、使用匿名内部类，直接用数组调用sort方法即可，比较的内容可以自己决定

 people1.sort(new Comparator<Person>() {
            @Override
            public int compare(Person person, Person t1) {
                if(person.score>t1.score){
                    return 1;
                }else if(person.score==t1.score){
                return 0;
            }
                return -1;}
        });

• 9.判断数组里面是否包含某一个元素，调用contains函数

      //判断数组里面是否包含某一个元素
        if(people1.contains(person)){
            System.out.println("有这个人");
        }else{
            System.out.println("没有这个人");
        }

• 10.获取某个对象的索引值，直接调用indexOf函数方法

       //获取某个对象的索引值
        System.out.println(people1.indexOf(person));

• 11.重新改变某个值，调用set函数，括号右边是替换的对象

    //重新改变某个值
        people1.set(0,person);

• 12.清空数组，调用clear函数

       //清空
        people1.clear();

二、Map使用

1.Map（映射）：也叫dictionary,里面包含键（key）和值（value），在里面键和值总在一起，称为键值对，（【key:value,key:value】），没有顺序

2.Map也是一个接口，Map以下还有一些子接口，常用的有三个：①HashMap：管理键值对 ②ConcurrentMap：线程安全 ③LinkedHashMap

注：它们三个的用法基本相同，所以以HashMap为例

3.HashMap的几种用法：先创建一个Map对象

Map<String,Person> map= new HashMap<>();

以下按顺序分别为（1）添加一个键值对（2）获取键值对的个数（3）判断是否包含某个key（4）判断是否包含某个值（5）获取某个key对应的值（6）删除键值对（7）替换键值对（8）清空键值对

  //添加一个键值对
        map.put("Jack",new Person(20,98,"Jack"));
       map.put("Rose",new Person(23,99,"Rose"));
       //获取键值对的个数
        System.out.println(map.size());
      //是否包含某个key
        System.out.println(map.containsKey("jack"));
        //是否包含某个值
        System.out.println(map.containsValue(people));
       //获取某个key对应的值
        Person p1=   map.get("jack");
        //删除键值对
        map.remove("jack");
        //替换
        map.replace("jack",new Person(33,55,"张三"));
       //清空
        map.clear();

（9）Map遍历，在Map里面还封装了Entry类，在这个类里面又有getKey()和getValue()方法，可以将这些键值对输出来

//map遍历
        Set<Map.Entry<String,Person>> entries =map.entrySet();
        for(Map.Entry<String ,Person> entry:entries){
            System.out.println("Key:"+entry.getKey()+" "+"value"+entry.getValue());
        }

这些内容和昨天的ArrayList里面的很多方法都类似，可以自行多多理解体会。

OK，以上就是我们今天的全部内容，再见！