Java学习day14：权限修饰符，集合（知识点＋例题详解）

声明：该专栏本人重新过一遍java知识点时候的笔记汇总，主要是每天的知识点+题解，算是让自己巩固复习，也希望能给初学的朋友们一点帮助，大佬们不喜勿喷(抱拳了老铁！)

往期回顾

Java学习day13：泛型（一篇文章搞懂）-CSDN博客

Java学习day12：static关键字，字符串声明，字符串常量池-CSDN博客

Java学习day11：异常-CSDN博客

......

Java学习day14：权限修饰符，集合

一、权限修饰符

其实咱们早就已经见过权限修饰符了

权限修饰符四个：
public private protected default(不写是叫default) 默认的

1.1private修饰符

private 修饰私有的成员变量和成员方法。

1.在本类中可以使用私有化的成员属性和成员方法

2.同一个包下面其他类不能使用私有化的成员属性和成员方法

3.其他的包的下面的其他类不能使用私有化的成员属性和成员方法

总结：private修饰的成员变量和成员方法只能在本类中使用

那如果想要去调用一个类的私有化方法，可以先在类的公有化方法里调用私有化方法，再在主类里调用公有化方法

1.2protected

protected修饰方法和属性

1.同一个类中可以使用的

2.同一个包下面其他类可以使用

3.不同包下面，如果是子类可以使用但是其他类不能使用

总结：其他包下面其他类不能使用，但是继承的子类可以使用的

1.3public

public修饰方法和属性是公开的，谁都可以。

1.4不写（默认的default）

default修饰方法和属性

1.在本类中默认的属性和方法是可以使用的

2.同一个包下面的其他类可以使用

3.其他包下面的其他类不能使用的

总结：默认的属性和方法只能在同一个包使用！！！

1.5总结

开发中最常用的是 private public

权限大小是逐级递减的

权限修饰符的名称	当前类	同一个包下面其他类	不同包下面子类	不同包下面的其他类
public	可以	可以	可以	可以
protected	可以	可以	可以	不可以
不写（默认default）	可以	可以	不可以	不可以
private	可以	不可以	不可以	不可以

二、集合(重点)

2.1集合的架构

看官方的API

interface Collection<E> 是java中集合的总接口

Collection下面有两个重要的子接口 List 和 Set

List 接口：
Collection下面的子接口，存储数据特征：有序的，可重复的
有两个比较重要的实现类:ArrayList LinkedList
Set 接口:
Collection下面的子接口，存储数据特征: 无序的，不可重复的
有两个比较重要的实现类: HashSet TreeSet

2.2collection接口

学习Collection这个接口，其实就是在学习这个接口下面的方法，

这些方法怎么调用呢？我们都知道，接口不能直接实例化，咋办？

借助于他的子类ArrayList即可，用多态

2.2.1主要方法

（1）增:

boolean add(E e);
boolean addAll(Collection<? extends E> c);

（2）删:

boolean remove(Object obj);
boolean removeAll(Collection<? extends E> c);
[a,b,c] [b, c, d]
void clear();

（3）查:

int size();
Object[] toArray();
boolean contains(Object obj);
boolean containsAll(Collection<? extends E> c);
boolean isEmpty();

不知道大家看的懂这些方法背后的含义不，该怎么使用，我建议大家，去看看官方API文档，这是学习一个新方法很好的途径。

希望大家都是看了再来看我这里的。

增:
boolean add(E e);添加一个数据到集合中
boolean addAll(Collection<? extends E> c); 将一个集合数据添加到另外一个集合中
Collection<? extends E>:元素是E本类或者继承的E，才能添加到另外一个集合中

删:
boolean remove(Object obj);删除指定的元素
boolean removeAll(Collection<? extends E> c); 删除的是交集
[a,b,c] [b, c, d]
void clear();清空的

查:
int size(); 查看集合中元素的个数
Object[] toArray(); 将集合转为Object类型数组
boolean contains(Object obj); 集合中是否包含这个元素如果包含返回true
boolean containsAll(Collection<? extends E> c);一个集合是否另外一个集合子集合
boolean isEmpty(); 判断集合是否为空

2.2.2示例

import java.util.ArrayList;
import java.util.Collection;

public class Demo {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<String>();//容器已经创建好了
        list.add("山山");
        list.add("福豪");
        list.add("忠达");
        System.out.println(list);
        Collection<String> list1 = new ArrayList<String>();
        list1.add("昊冉");
        list1.add("泽文");
        list1.add("梓宇");
        list.addAll(list1);
        Collection<Integer> list2 = new ArrayList<Integer>();
        list2.add(2);
        list2.add(89);
        //list.addAll(list2);直接报错
        System.out.println(list);//
        //[山山, 福豪, 忠达, 昊冉, 泽文, 梓宇]
        //删除  山山
        System.out.println(list.remove("山山"));//true
        System.out.println(list);//山山是否还在list集合中
        //[福豪, 忠达, 昊冉, 泽文, 梓宇]
        System.out.println(list.remove("老邢"));//fasle  删除一个不存在的数据的时候就是false
        Collection<String> list3 = new ArrayList<String>();
        list3.add("昊冉");
        list3.add("泽文");
        list3.add("山山");
        //list3["昊冉"， “泽文”, "山山"]
        //list[福豪, 忠达, 昊冉, 泽文, 梓宇]
        list.removeAll(list3);
        System.out.println(list);//[福豪, 忠达, 梓宇]
//        list.clear();
//        System.out.println(list);//[]
        //SIZE()
        System.out.println(list.size());//3
        //toArray();集合转数组
        Object[] objects = list.toArray();
        System.out.println(objects);//地址
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }
        System.out.println(list.contains("忠达"));//true
        System.out.println(list.contains("山山"));//false
        System.out.println(list.isEmpty());//false
        Object obj = "嘻嘻";
        System.out.println(obj);
    }
}

2.3遍历集合中的数据

2.3.1.使用for循环

这种是最基础的，将集合转为数组，然后再for循环遍历

import java.util.ArrayList;
import java.util.Collection;

public class Demo2 {
    public static void main(String[] args) {
        Collection<Integer> list = new ArrayList<>();
        list.add(250);
        list.add(360);
        list.add(470);
        list.add(404);
        list.add(500);
        System.out.println(list);
        //可以将集合转为数组，然后再for循环遍历
        //不用！！！
        Object[] objects = list.toArray();

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

2.3.2.增强for循环

2.3.2.1语法格式

for (集合中元素的数据类型临时变量：集合或者数组) {
sout（临时变量）
}

import java.util.ArrayList;
import java.util.Collection;

public class Demo3 {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        list.add("毛泽东");
        list.add("邓小平");
        list.add("江泽民");
        list.add("胡锦涛");
        System.out.println(list);
        //String s : list
        //将list集合 进行迭代，每次取一个值然后赋值给 s
        //将list集合中的数据挨个的赋值给s
        for (String s : list) {
            System.out.println(s);
        }
    }
}

2.3.3.迭代器

也是对集合中数据进行遍历的，分三步走

1.通过集合对象创建迭代器对象 cursor 光标指针

Iterator<String> iterator = list.iterator();

2.第一个方法 hasNext(); 判断一个集合中是否有下一个元素，有的话返回true，否则false

System.out.println(iterator.hasNext());//true

3.第二个方法next() 一个方法干了两件事情，首先会返回当前光标下面的元素，其次并把光标挪到下一元素的位置

System.out.println(iterator.next());

通过迭代器这一特性，我们用一个while循环，就可以实现集合数据的遍历输出，大家看代码。

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Demo4 {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        list.add("毛泽东");
        list.add("邓小平");
        list.add("江泽民");
        list.add("胡锦涛");

        //接下来咱们是哟个迭代器进行数据的遍历
        //1.通过集合对象创建迭代器对象 cursor  光标 指针
        Iterator<String> iterator = list.iterator();
        //2第一个方法  hasNext(); 判断一个集合中是否有下一个元素
       // System.out.println(iterator.hasNext());//true

        //3.next() 一个方法干了两件事情，
        //会返回当前光标下面的元素。并把光标挪到下一元素的位置
//        System.out.println(iterator.next());
//        System.out.println(iterator.hasNext());//true
//        System.out.println(iterator.next());
//        System.out.println(iterator.hasNext());//true
//        System.out.println(iterator.next());
//        System.out.println(iterator.hasNext());//true
//        System.out.println(iterator.next());
//        System.out.println(iterator.hasNext());//false
//        System.out.println(iterator.next());
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

2.4在集合中存的是自定义的对象【重点】

这里要特别注意一个问题，当集合中存的是自定义对象的时候，打印对象时会自动调用toString方法，而Java封装的toString方法里，打印的是内存地址，为了转换为方便我们看懂的，就需要重写toString方法。

toString()这个方法说白了就是返回类名+@+对象16进制的内存地址
是打印对象时自动调用的，所以说为了结果让人容易阅读，建议所以偶子类覆盖此方法，后面还会仔细讲解

public class Person {
    private String name;
    private int age;

    //有参构造方法，对属性进行赋值

    public Person(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;
    }
    //在一个类中重写toString方法
    //将内存地址转为程序员能看懂的字符串

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

public class Demo5 {
    public static void main(String[] args) {
        Person person = new Person("老邢", 78);
        System.out.println(person);//
        // 之前打印的person对象是内存地址，现在在类中重写了toString方法
        //以后，输出一个对象的话，就会打印出来一个字符串
        //在集合中添加person对象
        Collection<Person> list = new ArrayList<>();
        list.add(person);
        list.add(new Person("骚磊", 45));
        list.add(new Person("阳仔", 89));
        list.add(new Person("源哥", 35));
        System.out.println(list);
        Object[] objects = list.toArray();
        Person person1 = (Person)objects[1];
        System.out.println(person1.getName());

    }
}

大家可以跑一跑这段代码试试，重写toString方法和不重写情况下的区别。

当然，这里重写的方法，不知道大家看懂了吗？

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

看不懂，就多看几遍，再用idea跑一下看看输出结果，不是什么难题。

2.5List接口

List是Collection的子接口，而且实际开发中用List而不用Collection。因为List在Collection基础之上添加了很多的方法。

Collection下面的方法List肯定有的，因为是继承关系。上面讲了Collection下面的方法，在List中也可以用。接下来咱们讲List独有的方法。

2.5.1List独有的方法

增:
void add(int index, E e);在指定的位置上插入一个元素
boolean addAll(int index, Collection<? extends E> e);将一个集合插入到另外一个集合的指定的位置

删：
Collection删除的时候，通过元素来删除的。 remove(Object obj)
E remove(int index);通过索引来删除指定的元素。返回的是被删除的元素

改：
E set(int index, E e); 通过指定的索引修改数据元素，返回值是被修改的原数据

查:
E get(int index); 通过索引下标去获取指定元素
int indexOf(Object obj);通过元素获取指定的下标的
int lastIndexOf(object obj);通过元素获取最后一次出现的元素的下标
List<E> subList(int formIndex, int toIndex);截取一部分出来

2.5.1.1示例

大家仔细看示例，通过示例去熟悉方法。

import java.util.ArrayList;
import java.util.List;

public class Demo1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("张三");
        //有序的  可重复的
        System.out.println(list);//[张三, 李四, 王五, 张三]
        list.add(2, "狗蛋");
        System.out.println(list);
        List<String> list1 = new ArrayList<>();
        list1.add("麻子");
        list1.add("赵四");
        list1.add("贝贝");
        list.addAll(1, list1);
        System.out.println(list);

        System.out.println(list.remove(0));//在删除
        System.out.println(list);//目的是删除以后的集合的数据展示一下
        //[麻子, 赵四, 贝贝, 李四, 狗蛋, 王五, 张三]

        System.out.println(list.set(2, "彩云"));//贝贝
        System.out.println(list);//修改之后的集合
        System.out.println(list.get(0));
        System.out.println(list.get(1));
        System.out.println(list.get(2));
        System.out.println(list.get(3));
        //System.out.println(list.get(89));
        System.out.println(list.indexOf("麻子"));//0
        list.add(2, "张三");
        System.out.println(list.lastIndexOf("张三"));//7

        System.out.println(list);
        List<String> strings = list.subList(3, 5);
        System.out.println(strings);

    }
}

2.5.2遍历List集合中的数据

这里同样的三个方法，for循环、增强for循环、还有迭代器，跟遍历集合中的数据是一样的，就不再具体讲解太多。

2.5.2.1.for循环

import java.util.ArrayList;
import java.util.List;

public class Demo2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("张三");
        System.out.println(list);
        for (int i = 0; i < list.size(); i++) {
            //通过索引获取元素
            System.out.println(list.get(i));
        }
    }
}

2.5.2.2.增强for循环

import java.util.ArrayList;
import java.util.List;

public class Demo2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("张三");
        System.out.println(list);
        //for循环
//        for (int i = 0; i < list.size(); i++) {
//            //通过索引获取元素
//            System.out.println(list.get(i));
//        }
        //增强for循环
//        for (String s : list) {
//            System.out.println(s);
//        }
        //迭代器

    }
}

2.5.2.3.迭代器

根据光标位置的不同来判断是用hasNext()还是hasPrevious()

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class Demo3 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("张三");
        System.out.println(list);
        ListIterator<String> sli = list.listIterator();
        while (sli.hasNext()) {
            System.out.println(sli.next());
        }
        //此时光标已经在最下面了
        while (sli.hasPrevious()) {
            System.out.println(sli.previous());
        }

    }
}

或者改进一下

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class Demo4 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("张三");
        System.out.println(list);
        //可以将指针（光标）放到指定的额位置上，然后移动光标对数据进行遍历
        ListIterator<String> sli = list.listIterator(4);
        while (sli.hasPrevious()) {
            System.out.println(sli.previous());
        }
    }
}

2.6ArrayList

2.6.1特征

ArrayList底层是数组，可以扩容的。默认的容量是10.，超过10以后会自动扩容，扩容1.5倍

他查询快，增删慢。而我们实际开发就用ArrayList 因为开发的时候，主要查询多！！！

2.6.2示例

import java.util.ArrayList;

public class Demo1 {
    public static void main(String[] args) {
        //一般开发的时候写成 父类的引用指向子类的对象
        //因为List接口下面的方法已经够用了
        //ArrayList独有的方法很少，几乎不用  所以List
        ArrayList<String> list = new ArrayList<>();
        list.add("狗蛋");
        list.add(1, "老邢");
        list.add("老万");
        for (String s : list) {
            System.out.println(s);
        }
    }
}

2.7LinkedList

2.7.1特征

查询慢，增删快，LinkedList也是List的实现类，双向链表。

2.7.2示例

import java.util.LinkedList;

public class Demo1 {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("狗蛋");
        list.add("嘻嘻");
        list.addLast("哈啊哈");
        list.addFirst("呵呵");
        System.out.println(list);
        for (String s : list) {
            System.out.println(s);
        }
    }
}

2.8ArrayList和LinkedList和Vector的区别

ArrayList和Vector 底层是数组，但是Vector是线程安全的，所以效率底，开发中不用Vector

2.8.1ArrayList和linkedList区别:

ArrayList	linkedList
底层是数组	底层是双向链表
查询快：底层是索引，有序的通过内存有序地址，直接找到时间复杂度 o(1)	查询慢：底层是二分法查找的算法时间复杂度是log以2为底 n的对数
增删慢：增加数据和删除数据有可能扩容。每次扩1.5倍。扩容的话，浪费内存浪费时间o（n）	增删快：直接找前置结点 Node prev，后继结点 Node next。时间复杂度是 o(1)

总的来说，ArrayList适合需要频繁访问和修改元素的场景，LinkedList适合需要频繁插入和删除元素的场景，而Vector适合需要线程安全的场景。当然，实际开发的时候大部分用ArrayList

以上，就是今天的所有知识点了。集合这个知识点不难，丹斯要记的背的东西很多，大家得多花点时间，静下心慢慢看，慢慢理解，不是什么大问题。最后三个类的比较，我写的很简略，大家可以下来自行再拓展。

加油吧，预祝大家变得更强！