声明：该专栏本人重新过一遍java知识点时候的笔记汇总，主要是每天的知识点+题解，算是让自己巩固复习，也希望能给初学的朋友们一点帮助，大佬们不喜勿喷(抱拳了老铁！)
往期回顾
Java学习day12：static关键字，字符串声明，字符串常量池-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
以上，就是今天的所有知识点了。集合这个知识点不难，丹斯要记的背的东西很多，大家得多花点时间，静下心慢慢看，慢慢理解，不是什么大问题。最后三个类的比较，我写的很简略，大家可以下来自行再拓展。
加油吧，预祝大家变得更强！