多线程回顾、集合Collection、Set、List等基本知识

多线程回顾

问: 多线程的两种创建方式?

  1. 继承Thread类
  2. 实现Runnable接口
  3. 线程池
  4. Callable

问:多线程通常会遇到线程安全问题?

  1. 什么情况下会遇到线程安全问题?

    答:一个数据被多个线程访问(有读有写)

  2. 解决这个问题的方式?

    SE:同步锁 synchronized

    A : 同步代码块

    B : 同步方法

  3. 同步锁的要求

    A : 这多个线程必须使用同一个锁对象

    B : 同步锁的类型没有要求

  4. 同步方法的锁对象是谁?

    A : 非静态方法 : this

    B : 静态方法 : 当前类名.class

  5. 加同步锁的代码范围?

    单词的原子性的任务代码

    原子性 : 不可拆分,最小单位

    以一次卖一张票为例 , 本次和卖一张票有关的代码需要加锁

    ​ 判断票数是否够

    ​ 票数减少

    ​ 打印票号

问 : 线程通信

​ Object类的

  1. wait方法 : 让当前线程等待 , 进入阻塞状态

  2. notify和notifyAll

    notify : 随机唤醒一个等待的线程

    notifyAll : 唤醒所有等待的线程

    它们必须由同步锁调用 . 否则会报illegalMoritorStateException异常

问 : 线程的生命周期 Thread类

  1. 新建
  2. 可运行
  3. 阻塞 : 不限时
  4. 限时的等待
  5. 等锁
  6. 终结

一、集合

1.1集合与数组有什么区别?

数组 : 存储和管理一组数据的容器 .

数组特点:

  • 定长(数组长度不可变)
  • 元素类型相同
  • 索引从0开始
  • 元素连续存储
  • 元素既可以是基本数据类型 , 也可以是引用数据类型

集合 : 也是容器

集合的特点:

  • 长度可变
  • 元素类型相同
  • 有的是有序的 , (即可以根据索引操作) , 有的是无序的 (即不能根据数组索引操作)
  • 元素存储的结构很丰富 , 可能是数组 , 可能是链表等
  • 元素必须是引用数据类型

1.2集合的类型有哪些?

集合的类型可以分为两大类 :

​ (1) Collection系列 : 存储一组对象

例如: [“张三”,“李四”,“王五”]

​ (2) Map系列 : 存储一组键值对(key,value)

例如:[1=“张三”,2=“李四”]

Collection系列:

​ (1) List : 列表 , 允许元素重复 , 有序(可以根据索引操作元素)

​ (2) Set : 集 , 不允许元素重复 , 无序的(不可以根据索引操作元素)

​ (3) Queue : 队列 , 元素先进先出

1.3java.util.Collection接口

1.添加元素

  • public boolean add(E e) : 添加一个元素

    public class Exercise {public static void main(String[] args) {//Collection是这个系列集合的根接口//Collection coll = new Collection();   是错误的,因为Collection是一个接口,不能直接new对象Collection coll = new ArrayList();//Collection的子接口List的实现类ArrayList   此处为多态引用,左边是父接口的类型,右边是实现类的对象coll.add("哈哈");coll.add("嘻嘻");coll.add("嘿嘿");System.out.println(coll);  //自动调用ArrayList中重写的toString方法Collection coll2 = new ArrayList();coll2.add("丢丢");coll2.add("皮皮");System.out.println(coll2);coll.add(coll2);System.out.println(coll);}
}
//输出[哈哈, 嘻嘻, 嘿嘿]
//[丢丢, 皮皮]
//[哈哈, 嘻嘻, 嘿嘿, [丢丢, 皮皮]]

  • public boolean addAll(Collection<?extend E>c) : 添加一组元素 . 即把c集合中的一组元素添加到当前集合(this) . this = this ∪ c

    public class Exercise {public static void main(String[] args) {//Collection是这个系列集合的根接口//Collection coll = new Collection();   是错误的,因为Collection是一个接口,不能直接new对象Collection coll = new ArrayList();//Collection的子接口List的实现类ArrayList   此处为多态引用,左边是父接口的类型,右边是实现类的对象coll.add("哈哈");coll.add("嘻嘻");coll.add("嘿嘿");System.out.println(coll);  //自动调用ArrayList中重写的toString方法Collection coll2 = new ArrayList();coll2.add("丢丢");coll2.add("皮皮");System.out.println(coll2);coll.addAll(coll2);System.out.println(coll);}
}
//输出:
//[哈哈, 嘻嘻, 嘿嘿]
//[丢丢, 皮皮]
//[哈哈, 嘻嘻, 嘿嘿, 丢丢, 皮皮]

2、删除元素

  • public void clear() : 清空所有元素

    public class API_clear {public static void main(String[] args) {Collection coll = new ArrayList();coll.add("哈哈");coll.add("嘻嘻");coll.add("嘿嘿");coll.add("biubiu");System.out.println(coll);//删除  clear();清空coll.clear();		//清空所有}
}
//输出
//[哈哈, 嘻嘻, 嘿嘿, biubiu]
//

  • public boolean remove(Object o) : 在当前集合中找到与o相等的一个元素 , 然后删除它 , 并返回true , 如果没找到 , 就返回false

    public class API_clear {public static void main(String[] args) {Collection coll = new ArrayList();coll.add("哈哈");coll.add("嘻嘻");coll.add("嘿嘿");coll.add("biubiu");System.out.println(coll);coll.remove("biubiu");System.out.println(coll);}
}
//输出
//[哈哈, 嘻嘻, 嘿嘿, biubiu]
//[哈哈, 嘻嘻, 嘿嘿]

  • public boolean removeAll(Collection<?> c) : 从当前集合中删除所有和c集合中"相同的元素"

    this = this - this ∩ c

    public class API_removeAll {public static void main(String[] args) {Collection coll = new ArrayList();coll.add("哈哈");coll.add("嘻嘻");coll.add("嘿嘿");coll.add("biubiu");coll.add("diudiu");System.out.println(coll);Collection coll1 = new ArrayList();coll1.add("哈哈");coll1.add("biubiu");coll1.add("hello");System.out.println(coll1);coll.removeAll(coll1);//removeAll(c)  删除一组对象  删除掉coll ∩  c 元素//即  this = this - this ∩ cSystem.out.println(coll);}
}
//输出
//[哈哈, 嘻嘻, 嘿嘿, biubiu, diudiu]
//[哈哈, biubiu, hello]
//[嘻嘻, 嘿嘿, diudiu]

  • public boolean retainAll(Collection<?> c) : 从当前集合中删除所有和c集合中"不同的"元素 , 即当前集合中只留下和c集合相同的元素 . this = this ∩ c

    public class API_retainAll {public static void main(String[] args) {Collection coll = new ArrayList();coll.add("哈哈");coll.add("嘻嘻");coll.add("嘿嘿");coll.add("biubiu");coll.add("diudiu");System.out.println(coll);Collection coll1 = new ArrayList();coll1.add("哈哈");coll1.add("biubiu");coll1.add("hello");System.out.println(coll1);coll.retainAll(coll1);System.out.println(coll);}
}
//输出
//[哈哈, 嘻嘻, 嘿嘿, biubiu, diudiu]
//[哈哈, biubiu, hello]
//[哈哈, biubiu]

  • public default boolean removeIf(Predicate<? super E>filter) : JDK8引入的 . 从当前集合中删除Predicate接口的实现类的test方法判断为true的元素 . 在Predicate接口的实现类中会重写一个boolean test(E element)方法 , 该方法用于判断当前集合的元素是否满足xx条件 .

    在removeIf方法中 , 会遍历集合所有元素 , 并将元素作为实参传给test方法中的条件 , 则返回true , 该元素就会被删除 ; 该元素不满足test方法中的条件 , 则返回false , 该元素就会被保留

    public class API_removeIf {public static void main(String[] args) {//需求:删除包含a字母的单词,现在要求根据条件删除//boolean removeIf(Predicate filter)//Predicate是一个接口,包含一个抽象方法  boolean test(Object t)//在这个抽想方法中,是编写判断t对象的条件 , 如果t对象满足xx条件 ,就返回true,如果不满足xx条件,就返回false//当我们把Predicate接口的实现类对象放到removeIf方法中,就表示满足test条件的,要被删除,不满足test的条件就不删除Collection coll = new ArrayList();coll.add("哈哈");coll.add("嘻嘻");coll.add("嘿嘿");coll.add("biubiu");System.out.println(coll);coll.removeIf(new Predicate() {@Overridepublic boolean test(Object o) {if(o instanceof String){/*String str = (String) o;if(str.contains("b")){return true;}else{return false;}*/return ((String)o).contains("b");}return false;}});System.out.println(coll);}
}
//输出
//[哈哈, 嘻嘻, 嘿嘿, biubiu]
//[哈哈, 嘻嘻, 嘿嘿]

3、查询元素

  • public boolean contains(Object obj)：用于判断当前集合是否包含obj这个对象。
  • public int size()：用于返回当前集合的元素的总个数。
  • public boolean isEmpty()：判断当前集合是否为空。
  • public Object[] toArray() ：把当前集合中所有元素放到一个Object[]数组中返回。
  • public boolean containsAll(Collection<?> c)：用于判断当前集合是否包含c集合的所有对象。即判断c集合是否是当前集合的“子集”。如果c是this的子集，返回true，否则返回false。
public class API {@Testpublic void test() throws Exception{Collection coll = new ArrayList();coll.add("hello");coll.add("world");coll.add("java");coll.add("atguigu");coll.add("chailinyan");coll.add("chailinyan");//查询://(1)查询当前集合中是否有"java"这个单词System.out.println(coll.contains("java"));   //true//(2)查询集合中元素的个数System.out.println(coll.size());   //6//(3)判断当前集合是否为空System.out.println(coll.isEmpty());   //false//(4)把集合的元素,放到一个数组中返回Object[] arr = coll.toArray();System.out.println(Arrays.toString(arr));//[hello, world, java, atguigu, chailinyan, chailinyan]//(5)查询是否包含一组对象Collection coll2 = new ArrayList();coll2.add("hello");coll2.add("java");System.out.println(coll.containsAll(coll2));        //truecoll2.add("dwt");System.out.println(coll.containsAll(coll2));        //false  因为添加新元素dwt后,coll2就不再是coll的子集}
}

4、遍历

  • foreach循环遍历 IDEA快捷键iter
  • public Iterator iterator()：返回一个Iterator迭代器对象，用于遍历容器中的元素。

1.4增强for循环(foreach循环)

1、foreach循环语法格式

语法格式:

for(元素的类型 元素名 : 集合对象名或数组对象名){//遍历集合或数组元素要做的事
}

public class Test {@org.junit.Testpublic void test() throws Exception{Collection coll = new ArrayList();coll.add("hello");coll.add("world");coll.add("java");coll.add("atguigu");coll.add("dwt");for (Object obj : coll) {System.out.println(obj+"的长度:"+((String)obj).length());}}
}

2、增强for循环与普通for循环有什么区别

  • 遍历数组 : 增强for循环没有下标 , 普通for循环有下标
  • 普通for循环可以用于 , 重复执行某些代码的任意场景 , 但是增强for循环只能用于遍历集合与数组

3、是不是所有的集合/容器都可以使用foreach呐?

答 : 不是 , 只有实现了java.lang.Iterable接口的集合才可以使用增强for循环 , Collection接口继承了Ierable接口 , 所以Collection系列的集合都是Iterable接口的实现类 , Map系列的集合不支持增强for循环我们自己定义的集合想要使用增强for循环 , 就实现Iterable接口即可.

4、Iterable接口是否包含抽象方法呢?

答案 : 包含 抽象方法为: Iterator iterator()

5、Iterable与Iterator的联系

  • 凡是实现Iterable接口的集合等类型 , 都包含了Iterator iterator() , 也就是说 , 必须重写该方法 , 要提供一个迭代器的实现类
  • 对于foreach循环来说 , 对集合使用foreach , 本质上是用集合的迭代器在遍历
    • foreach只是一个语法糖
      • 遇到集合 , 就会转换为迭代器遍历
      • 遇到数据 , 就会转换为普通for循环
public class Collection_array {@Testpublic void test() throws Exception{Collection coll = new ArrayList();coll.add("hello");coll.add("world");coll.add("java");coll.add("atguigu");//使用foreach遍历集合for (Object o : coll) {System.out.print(o+" ");  //看起来再使用foreach，本质上仍然是Iterator迭代器}System.out.println();System.out.println("------------------------");int[] arr = {1,2,3,4,5};for (int i : arr) {System.out.print(i+" ");}}
}
//输出
//hello world java atguigu 
//------------------------
//1 2 3 4 5
1694754249609

6、Iteroator和Iterable的区别

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

1.5迭代器

1、迭代器遍历集合

迭代器的接口 : java.util.Iterator接口 , 包含两个抽象方法

  • boolean hasNext() : 判断当前集合是否还有元素可迭代
  • Object next() : 取出迭代器当前位置的元素,并让迭代器指向下一个元素的位置
public class Test {@org.junit.Testpublic void test() throws Exception{Collection coll = new ArrayList();coll.add("hello");coll.add("world");coll.add("java");coll.add("atguigu");//使用Iterator迭代器 遍历 coll集合的元素//需求：查看上面集合的所有元素，并且输出这些字符串的长度Iterator iterator = coll.iterator();//这里调用了集合的iterator()方法，得到是Iterator接口的实现类的对象//iterator迭代器对象的 作用 遍历 coll集合的元素while (iterator.hasNext()){     //判断集合是否还有元素可迭代Object obj = iterator.next();   //取出迭代器当前位置的元素，并让迭代器指向下一个元素的位置System.out.println(obj + "的长度:" + ((String)obj).length());}}
}
//输出:
hello的长度:5
world的长度:5
java的长度:4
atguigu的长度:7

2、对比Iterable和Iterator

java.lang.Iterable接口:可迭代的,形容词able结尾集合类型实现Iterable接口,表示集合可迭代的java.util.Iterator接口:迭代器,名词or专门有一些类实现Iterator接口,用于遍历或迭代集合的元素每一种集合都有自己的迭代器类型,这些迭代器类型通常都在集合的内部,以成员内部类方式存在这里涉及到一个设计模式,迭代器模式.
面向对象的开发原则:高内聚低耦合高内聚,ArrayList集合,它底层是数组,它内部有一个专用的迭代器Itr成员内部类可以直接访问外部类的所有的成员,包括私有的.这里表示迭代器可以访问到外部集合;类型的所有元素.而且这个迭代器Itr类型只为当前的ArrayList服务,所以选用成员内部类方式实现(体现高内聚)低耦合:外部使用这些集合的迭代器时,不需要关心它的内部打开类的搜索框快捷键  ctrl+N查看类的成员列表快捷键  alt + 7

3、用foreach还是lterator

问题 : 遍历集合既可以使用foreach , 又可以使用Iterator迭代器 , 那么到底用哪个?

  • 如果只是查看元素 , 优先选择foreach , 代码更简洁、明了
  • 如果在遍历集合元素过程中 , 要删除元素 , 只能用Iterator , 而不能用foreach

Iterator迭代器的意义:

  • foreach本身用的就是迭代器
  • 在Java8之前 , Collection集合是没有removeIf方法的 , 无法根据条件删除元素 , 所以迭代器Iterator接口提供了一个方法 , 用于在遍历集合元素的过程中 , 根据条件删除元素 . 当然 , 现在已经是jdk8及以上的版本了 , 可以直接使用Collection中的removeIf方法 , 优先选择它

4、Iterator迭代器删除元素问题

Iterator接口有一个方法 : void remove() , 用于删除迭代器刚刚遍历的集合元素

这个方法在早期是Iterator接口的一个抽象方法 (实现类必须重写) , java8以后 , 改为默认方法 (实现类可以重写 , 也可以不重写)

因为早期集合没有removeIf方法 , 所以 , 要根据条件删除元素时 , 必须使用迭代器一边遍历 , 一边判断条件 , 使用迭代器的remove方法 . Java8以后 , 引入了removeIf方法 , 开始建议大家使用removeIf方法 , 新的集合内部类的迭代器类型可以重写 , 也可以不重写迭代器的remove方法

@Test
public void test1() throws Exception{Collection coll = new ArrayList();coll.add("hello");coll.add("world");coll.add("java");coll.add("atguigu");//需求:删除"java//方法一:直接使用Collection中的remove()方法,在ArrayList中的实现//        coll.remove("java");//        System.out.println(coll);//方法二:使用迭代器遍历删除Iterator iterator = coll.iterator();while (iterator.hasNext()){Object obj = iterator.next();if("java".equals(obj)){iterator.remove();}}System.out.println(coll);
}

@Test
public void test3() throws Exception{Collection coll = new ArrayList();coll.add("hello");coll.add("world");coll.add("java");coll.add("atguigu");//需求：删除包含a字母的单词//方式二：JDK1.2之后都能用,迭代器删除Iterator iterator = coll.iterator();while (iterator.hasNext()){Object obj = iterator.next();if(((String)obj).contains("a")){iterator.remove();   //此处调用的时iterator的remove()方法}}
}

错误示范 , 在迭代器中用了Collection的remove方法 , 会发生异常java.util.ConcurrentModificationException

@Test
public void test4() {//foreach不能删除元素Collection coll = new ArrayList();coll.add("hello");coll.add("world");coll.add("java");coll.add("atguigu");//需求：删除包含a字母的单词//方式二：JDK1.2之后都能用,迭代器删除for (Object obj : coll) {if(((String)obj).contains("a")){coll.remove(obj);   //此处调用的时Collection的remove()方法//编译没有问题 , 但是一运行就报错异常:java.util.ConcurrentModificationException	}}
}

5、迭代器原理分析

ArrayList集合的相关变量：
Object[]  elementData ：数组，用于存储元素
int size：用于记录元素个数
int modCount：用于记录元素个数变化次数，添加或删除元素都会使得modCount值+nArrayList内部类Itr的相关变量：
int cursor：迭代器当前游标值，即迭代器当前指向elementData元素的下标值
int lastRet：迭代器刚刚访问过的元素下标值，如果迭代器还未访问过元素，或者刚刚访问过的元素已被删除，那么它的值为-1，表示该元素不存在了。
int exepectedModCount：迭代器“预计的”modCount值，它应该与ArrayList的modCount值相等，否则就说明集合在迭代器之外修改了集合，对集合做了添加或删除元素操作。要求：（1）迭代器的exepectedModCount始终要与集合的modCount一致。所以只有调用迭代器的remove删除方法，才能保证它们始终是一致的。（2）集合的元素删除了，迭代器应该回退一下，保证所有元素都被遍历和检查到。

总的结论 : 在使用foreach或Iterator迭代器遍历集合的过程中 , 千万不要调用集合的remove , add 等方法 , 如果要删除元素 , 调用迭代器的remove方法 .

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

二、Set集合

2.1Set集合类型

Set集合是Collection集合的一个分支

Collection是一个接口 , Set是它的子接口 . 而且Set这个子接口没有扩展新方法 , 用的都是Collection接口的方法 .

Set接口有很多实现类 , 其中比较常用的实现类 :

  • HashSet : 元素是散列存储 , 看起来完全无规律
  • LinkedHashSet : 元素也是散列存储 , 但是它内部有一个双向链表来记录元素的**“添加顺序”**
    • 上面两个集合区分元素是否有重复 , 就看元素hashCode值和equals方法
  • TreeSet : 元素有规律存储 , 按照元素的大小顺序存储 , 以二叉树存储 . 必须依赖Comprable接口或Comparator接口 , 如果是自定义类 , 则必须实现这两个比较接口才可以TreeSet
    • 区分元素是否有重复 , 就是看元素大小是否相同

共同特征: 元素是不可重复的 , 无序的(这里无序的意思是Set接口没有提供通过索引来操作元素的方法)

//HashSet@Testpublic void testHashSet() throws Exception{HashSet hashSet = new HashSet();hashSet.add("hello");hashSet.add("java");hashSet.add("world");hashSet.add("haha");hashSet.add("haha");System.out.println(hashSet);}
//输出:[haha, java, world, hello]
可以看出 , HashSet是无序的 , 且元素不可重复 , 看起来毫无规律

//LinkedHashSet@Testpublic void testLinkedHashSet() throws Exception{LinkedHashSet linkedHashSet = new LinkedHashSet();linkedHashSet.add("hello");linkedHashSet.add("java");linkedHashSet.add("world");linkedHashSet.add("haha");linkedHashSet.add("java");System.out.println(linkedHashSet);}
//输出:[hello, java, world, haha]
可以看出 , LinkedHashSet元素也是不可重复的 , 但是看似有规律(规律为按照添加顺序排序)

//TreeSet自然排序@Testpublic void testTreeSet() throws Exception {//演示TreeSet用树存储,有规律,按照大小顺序排序(自然顺序)TreeSet treeSet = new TreeSet();treeSet.add("hello");treeSet.add("java");treeSet.add("world");treeSet.add("haha");treeSet.add("abc");treeSet.add("java");System.out.println(treeSet);//String类型的对象可以比较大小,因为String类实现了java.lang.Comparable自然比较接口,重写了 int compareTo(Object obj)}
//输出:[abc, haha, hello, java, world]自然排序 : 是按照字符串的字符的编码值比较大小如果两个字符串的前面字符全部相同 , 那么 短< 长

Comparable:以able结尾,形容词,表示可比较大小的哪个类的对象要比较大小,哪个类实现它即可String对象要比较大小,String类实现Comparable即可
Comparator:以or结尾,名称,表示比较器. 比较器的对象用于比较另外某个类的两个对象单独编写一个类,实现Comparator接口,例如 MyComparator类重写 int compare(Object o1,Object o2)MyComparator类的对象调用compare可以用来比较两个字符串的对象 

//TreeSet定制排序	@Testpublic void testTreeSet1() throws Exception{//演示TreeSet用树存储,有规律,按照大小顺序排序(定制顺序:如按照字符串的长度排序)MyComparator m1 = new MyComparator();TreeSet treeSet = new TreeSet(m1);treeSet.add("hello");treeSet.add("java");treeSet.add("world");treeSet.add("haha");treeSet.add("abc");treeSet.add("java");System.out.println(treeSet);}
//输出[abc, haha, java, hello, world]

public class MyComparator implements Comparator {@Overridepublic int compare(Object o1, Object o2) {//运行时,o1和o2都是String类型String s1 = (String) o1;String s2 = (String) o2;int result = s1.length() - s2.length();//长度不同,看长度,长度不同看内容return result == 0 ? s1.compareTo(s2) : result;}
}

2.2hashCode方法和equals方法

1、java.lang.Object类

boolean equals(Object obj)：比较两个对象是否相等。

int hashCode()：相当于计算对象的身份证号，用对象的属性值计算对象的身份证号码。它就是一个int值。

hashCode方法的返回值的作用，只有1个，用于计算元素在HashSet、HashMap等和hash有关的集合中的存储位置。

2、重写hashCode方法要求

  • 同一个对象，如果属性值没有改变，前后两次调用hashCode方法返回结果必须相同。
  • 不同的两个对象，equals比较不同（返回false），hashCode方法按理说应该不同的，最好也不同，但是实际上可能存在相同。y=f(x)不同的x，可能得到相同的y。
  • 相同的两个对象，equals比较相同（返回true），hashCode方法返回结果必须相同。
    • 两个对象的hashCode值不同，那么equals方法一定返回false。

3、重写hashCode方法和equals方法的快捷键：Alt + Insert

public class Test1 {@Testpublic void test() throws Exception{//员工目前没有重写hashCode方法Student s1 = new Student("张三", 18); //重写前 1012570586    重写后 24022538Student s2 = new Student("张三", 18); //重写前 1207140081    重写后 24022538System.out.println(s1.hashCode());System.out.println(s2.hashCode());/** hashCode是一个int值,它是根据对象的"特征"用散列函数计算出来的一个int值* 不同品牌的JVM,对于Object类的hashCode方法的计算规则不一样* 有的JVM里面是用内存定制作为对象特征,来计算hashCode值* 有的JVM里面是用对象的属性值作为对象的特征,来计算hashCode值** Object类的equals方法的源码是 this==obj , 比较地址值** 子类通常会重写hashCode方法,一般都是对对象的属性值作为对象的特征,来计算hashCode值* 两个对象属性值相同,hashCode值应该相同* 两个对象属性值相同,equals方法应该也相同* */}@Testpublic void test2() throws Exception{HashSet hashSet = new HashSet();hashSet.add("hello");hashSet.add("java");hashSet.add("world");hashSet.add("haha");hashSet.add("Aa");hashSet.add("BB");System.out.println(hashSet);}
}

2.3概念比喻

Collection集合：比喻，篮子、箱子，一种容器，用来装东西，Java中用来装对象的。

Iterable接口：表示可迭代，比喻是列车，上面可以去查看乘客的个数、乘客的情况 （验票）

Iterator接口：表示迭代器，比喻乘务员。为列车和列车上的乘客的服务。迭代器为集合和集合的元素服务的。

Comparable接口：自然比较接口。自然比较规则，通常是默认的，首先想到的比较规则。

举个例子：两个学生，要比较大小。通常是比较年龄，学生类实现Comparable接口，默认按照年龄比较大小。

Comparator接口：定制比较器接口。

举个例子：两个学生，要比较大小。定制是比较身高，成绩等。这个时候，需要老师这个角色，这个人作为比较器，查看两个学生的身高（体育老师），成绩（Java老师）。不同的老师，充当不同的比较器的角色。如果有多种比较的需求，就需要定义多个比较器的类。

Object类有两个方法：

boolean equals（Object obj）：比较两个对象是否相等。

int hashCode()：返回int对象的身份证号码。相当于用一个整数值代表一个对象的特征。

Set：是一种特殊的集合，无序和不可重复。如果数学好的同学，可以把它直接理解为数学中的集的概念。

三、List集合

3.1List集合的特征

List是有序的 , 可重复的

public class TestList {@Testpublic void test() throws Exception{ArrayList arrayList = new ArrayList();arrayList.add("张三");arrayList.add(0,"李四");arrayList.add("张三");System.out.println(arrayList);System.out.println(arrayList.get(2));}
}
//输出[李四, 张三, 张三]
//张三

3.2List接口的方法

List接口是Collection的子接口

1、添加

  • public void add(int index, E element)：把新元素element添加到指定到当前集合列表的[index]位置。

  • public boolean addAll(int index, Collection<? extends E> c)：将c集合的所有元素添加到指定到当前集合列表的[index]位置。

    	@Testpublic void test2() throws Exception{ArrayList arrayList = new ArrayList();arrayList.add("张三");arrayList.add(0,"李四");arrayList.add("张三");ArrayList arrayList1 = new ArrayList();arrayList1.add("熊大");arrayList1.add("熊二");arrayList1.add("光头强");//public boolean addAll(int index, Collection<? extends E> c)//需求:将arrayList1中所有的元素插入的arrayList中的最前面arrayList.addAll(0,arrayList1);System.out.println(arrayList);}
//输出 [熊大, 熊二, 光头强, 李四, 张三, 张三]

2、删除

  • public E remove(int index)：删除当前集合列表中[index]位置的元素，并返回被删除元素。

    	@Testpublic void test3() throws Exception{ArrayList arrayList = new ArrayList();arrayList.add("张三");arrayList.add(0,"李四");arrayList.add("张三");ArrayList arrayList1 = new ArrayList();arrayList1.add("熊大");arrayList1.add("熊二");arrayList1.add("光头强");arrayList.addAll(0,arrayList1);//需求:删除索引3位置上的元素//public E remove(int index)arrayList.remove(3);System.out.println(arrayList);}
//输出:[熊大, 熊二, 光头强, 张三, 张三]

3、修改

  • public E set(int index, E ele)：替换当前集合列表中[index]位置的元素，并返回被替换的元素。

  • public default void replaceAll(UnaryOperator operator)：JDK8引入的。实现UnaryOperator接口时必须重写public E apply(E oldValue) 方法。在replaceAll方法中会遍历集合的所有元素，并将每一个元素作为实参传给apply方法，然后用apply方法的返回值作为newValue替换该元素。

  • pubilc default void sort(Comparator<? super E> c)：使用定制比较器对象c，对当前集合列表的元素排序。

    //set@Testpublic void test4() throws Exception{ArrayList arrayList1 = new ArrayList();arrayList1.add("熊大");arrayList1.add("熊二");arrayList1.add("光头强");//需求:把索引2上的元素,替换为"灰太狼"//public E set(int index, E ele) 替换当前集合列表中[index]位置的元素，并返回被替换的元素Object o = arrayList1.set(2, "灰太狼");    //返回被替换的元素System.out.println(o);System.out.println(arrayList1);}
//输出
光头强
[熊大, 熊二, 灰太狼]

    //void replaceAll(UnaryOperator<E> operator)@Testpublic void test5() throws Exception{ArrayList arrayList1 = new ArrayList();arrayList1.add("熊大");arrayList1.add("熊二");arrayList1.add("光头强");arrayList1.add("光头强");arrayList1.add("高启强");arrayList1.add("超人强");/*** void replace(UnaryOperator operator)形参类型 UnaryOperator接口* 这个接口有一个抽象方法 T apply(T t)* 调用replaceAll方法:需要传入一个UnaryOperator接口的实现类对象* 重写 T apply(T t):  t是原来的元素,apply方法返回的值是 新的元素*              t代表list集合中的这些主人公元素*              apply方法的返回值分两种情况:*                  (1)如果t不包含"强",则返回t*                  (2)如果t包含"强",则返回"GGB"*/arrayList1.replaceAll(new UnaryOperator() {@Overridepublic Object apply(Object obj) {/*String str = (String) obj;if(str.contains("强")){return "GGB";}else{return obj;}*///可以简写如下return ((String)obj).contains("强") ? "GGB" : obj;}});System.out.println(arrayList1);}
//[熊大, 熊二, GGB, GGB, GGB, GGB]

    //pubilc default void sort(Comparator<? super E> c)
@Testpublic void test6() throws Exception {ArrayList list = new ArrayList();list.add(1);list.add(5);list.add(3);list.add(2);System.out.println(list);  //List是有序的 此时应该输出[1,5,3,2]list.sort(new Comparator() {@Overridepublic int compare(Object o1, Object o2) {return (Integer) o1 - (Integer) o2;}});System.out.println(list);   //输出[1,2,3,5]}

4、查询

  • public E get(int index)：返回当前集合列表中[index]位置的元素
  • public List subList(int fromIndex, int toIndex)：返回当前集合列表中[fromIndex, toIndex)范围的元素

  • public int indexOf(Object obj)：在当前集合列表中查询obj元素的位置，如果存在多个obj，则返回第1次出现的位置。

  • int lastIndexOf(Object obj)：在当前集合列表中查询obj元素的位置，如果存在多个obj，则返回最后1次出现的位置。

    @Testpublic void test7() throws Exception{ArrayList list = new ArrayList();list.add("光头强");list.add("熊大");list.add("光头强");list.add("熊二");list.add("光头强");System.out.println(list.indexOf("光头强"));//[0]System.out.println(list.lastIndexOf("光头强"));//[4]System.out.println(list.get(1));//熊大System.out.println(list.subList(2,4));//[光头强, 熊二]  含头不含尾，  等价于  左闭右开 [2,4)}

{
return (Integer) o1 - (Integer) o2;
}
});
System.out.println(list); //输出[1,2,3,5]
}


### 4、查询- public E get(int index)：返回当前集合列表中[index]位置的元素
- public List subList(int fromIndex, int toIndex)：返回当前集合列表中[fromIndex, toIndex)范围的元素* public int indexOf(Object obj)：在当前集合列表中查询obj元素的位置，如果存在多个obj，则返回第1次出现的位置。* int lastIndexOf(Object obj)：在当前集合列表中查询obj元素的位置，如果存在多个obj，则返回最后1次出现的位置。~~~java
@Testpublic void test7() throws Exception{ArrayList list = new ArrayList();list.add("光头强");list.add("熊大");list.add("光头强");list.add("熊二");list.add("光头强");System.out.println(list.indexOf("光头强"));//[0]System.out.println(list.lastIndexOf("光头强"));//[4]System.out.println(list.get(1));//熊大System.out.println(list.subList(2,4));//[光头强, 熊二]  含头不含尾，  等价于  左闭右开 [2,4)}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/80013.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

VisualStudio Code 支持C++11插件配置

VisualStudio Code 支持C++11插件配置

问题 Visual Studio Code中的插件: Code Runner 支持运行C、C、Java、JS、PHP、Python等多种语言。 但是它不支持C11特性的一些使用&#xff0c;比如类似错误&#xff1a; binarySearch.cpp:26:17: error: non-aggregate type ‘vector’ cannot be initialized with an ini…
阅读更多...
【深度学习】 Python 和 NumPy 系列教程（十）：NumPy详解：2、数组操作（索引和切片、形状操作、转置操作、拼接操作）

【深度学习】 Python 和 NumPy 系列教程（十）：NumPy详解：2、数组操作（索引和切片、形状操作、转置操作、拼接操作）

目录 一、前言 二、实验环境 三、NumPy 0、多维数组对象&#xff08;ndarray&#xff09; 1. 多维数组的属性 1、创建数组 2、数组操作 1. 索引和切片 a. 索引 b. 切片 2. 形状操作 a. 获取数组形状 b. 改变数组形状 c. 展平数组 3. 转置操作 a. 使用.T属性 b…
阅读更多...
安全实战 | 怎么用零信任防范弱密码？

安全实战 | 怎么用零信任防范弱密码？

防范弱密码&#xff0c;不仅需要提升安全性&#xff0c;更需要提升用户体验。 比如在登录各类业务系统时&#xff0c;我们希望员工登录不同系统不再频繁切换账号密码&#xff0c;不再需要3-5个月更换一次密码&#xff0c;也不再需要频繁的输入、记录、找回密码。 员工所有的办…
阅读更多...
实验室预约系统设计与实现

实验室预约系统设计与实现

实验室预约系统的设计 摘 要 目前各大学的实验项目日益繁多&#xff0c;如何合理预约实验室&#xff0c;已经成为当今各个大学实验室课程预约的难题。因此&#xff0c;这个实验室预约系统就是研究实验室预约的相关问题。实验室预约系统的设计主要是基于B/S模型&#xff0c;在W…
阅读更多...
Vector 模拟实现

Vector 模拟实现

前言 本文将会向您介绍如何模拟实现vector 引入 Vector是一种动态数组&#xff0c;也是C标准库中的容器之一。它提供了一种存储和操作一系列元素的方式&#xff0c;类似于数组&#xff0c;但具有更多的功能和灵活性。 Vector可以存储不同类型的元素&#xff0c;并且可以根据…
阅读更多...
【ChatGPT原理与实战】4个维度讲透ChatGPT技术原理，揭开ChatGPT神秘技术黑盒！

【ChatGPT原理与实战】4个维度讲透ChatGPT技术原理，揭开ChatGPT神秘技术黑盒！

&#x1f680;欢迎来到本文&#x1f680; &#x1f349;个人简介&#xff1a;陈童学哦&#xff0c;目前学习C/C、算法、Python、Java等方向&#xff0c;一个正在慢慢前行的普通人。 &#x1f3c0;系列专栏&#xff1a;陈童学的日记 &#x1f4a1;其他专栏&#xff1a;CSTL&…
阅读更多...
HarmonyOS开发：那些开发中常见的问题汇总（一）

HarmonyOS开发：那些开发中常见的问题汇总（一）

前言 本来这篇文章需要讲述静态共享包如何实现远程依赖和上传以及关于静态共享包私服的搭建&#xff0c;非常遗憾的告诉大家&#xff0c;由于组织管理申请迟迟未通过&#xff0c;和部分文档官方权限暂未开放&#xff0c;关于这方面的讲解需要延后了&#xff0c;大概需要等到202…
阅读更多...
哈工大校园网显示IP地址错误连接不上

哈工大校园网显示IP地址错误连接不上

您当前获取到的IP地址有误&#xff0c;请重新开关无线获取IP地址(注:电脑端还可以通过cmd窗口&#xff0c;输入ipconfig /release、ipconfig /renew命令)。如未解决此问题请联系网络安全和信息化办公室处理。 当校园网登录时会出现如上情况&#xff0c;并且当你按照他的方法尝试…
阅读更多...
数据结构——图(图的存储及基本操作)

数据结构——图(图的存储及基本操作)

文章目录 前言一、邻接矩阵法&#xff08;顺序存储&#xff09;1.无向图存储邻接矩阵算法2.有向图存储邻接矩阵算法 二、邻接表法(图的链式存储结构)总结 前言 邻接矩阵法(图的顺序存储结构) 1.1 无向图邻接矩阵算法 1.2 有向图邻接矩阵算法邻接表法(图的一种链式存储结构) 一…
阅读更多...
56、springboot ------ RESTful服务及RESTful接口设计

56、springboot ------ RESTful服务及RESTful接口设计

★ RESTful服务 RESTful服务是“前后端分离”架构中的主要功能&#xff1a; 后端应用对外暴露RESTful服务&#xff0c;前端应用则通过RESTful服务与后端应用交互。后端应用 RESTful接口 <------------------> 前端★ 基于JSON的RESTful服务 使用RestController注解…
阅读更多...
vue项目部署，出现两个ip的原因

vue项目部署，出现两个ip的原因

我宁愿靠自己的力量打开我的前途,而不愿求有力者的垂青。——雨果 tags: 篇首语&#xff1a;本文由小常识网(cha138.com)小编为大家整理&#xff0c;主要介绍了vue项目部署&#xff0c;出现两个ip的原因相关的知识&#xff0c;希望对你有一定的参考价值。 参考技术A 在部署v…
阅读更多...
建站系列（五）--- 前端开发语言之HTML、CSS、JavaScript

建站系列（五）--- 前端开发语言之HTML、CSS、JavaScript

目录 相关系列文章前言一、前端开发与后端开发二、前端语言简介&#xff08;一&#xff09;、HTML&#xff08;二&#xff09;、CSS&#xff08;三&#xff09;、JavaScript 三、学习指导&#xff08;一&#xff09;、开发环境&#xff08;二&#xff09;、第一个Hello&#xf…
阅读更多...
央媒发稿不能改？媒体发布新闻稿有哪些注意点

央媒发稿不能改？媒体发布新闻稿有哪些注意点

传媒如春雨&#xff0c;润物细无声&#xff0c;大家好&#xff0c;我是51媒体网胡老师。 “央媒发稿不能改”是媒体行业和新闻传播领域的普遍理解。央媒&#xff0c;即中央主要媒体&#xff0c;是权威性的新闻源&#xff0c;当这些媒体发布新闻稿或报道时&#xff0c;其他省、…
阅读更多...
Pdf文件签名检查

Pdf文件签名检查

如何检查pdf的签名 首先这里有一个已经签名的pdf文件&#xff0c;通过pdf软件可以看到文件的数字签名。 下面就是如何代码检查这里pdf文件的签名 1.引入依赖 <dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId&g…
阅读更多...
时序预测 | MATLAB实现ARMA自回归移动平均模型时间序列预测

时序预测 | MATLAB实现ARMA自回归移动平均模型时间序列预测

时序预测 | MATLAB实现ARMA自回归移动平均模型时间序列预测 目录 时序预测 | MATLAB实现ARMA自回归移动平均模型时间序列预测预测效果基本介绍程序设计参考资料 预测效果 基本介绍 MATLAB实现ARMA时间序列预测&#xff08;完整源码和数据&#xff09; 本程序基于MATLAB的armax函…
阅读更多...
应用在电子体温计中的国产温度传感芯片

应用在电子体温计中的国产温度传感芯片

电子体温计由温度传感芯片&#xff0c;液晶显示器&#xff0c;纽扣电池&#xff0c;专用集成电路及其他电子元器件组成。能快速准确地测量人体体温&#xff0c;与传统的水银玻璃体温计相比&#xff0c;具有读数方便&#xff0c;测量时间短&#xff0c;测量精度高&#xff0c;能…
阅读更多...
gma 2.0.1 (2023.09.15) 更新日志

gma 2.0.1 (2023.09.15) 更新日志

安装 gma 2.0.1 pip install gma2.0.1修复 1、【栅格处理-栅格分解】   修复了由于关联模块调整导致类方法失效引起的函数功能异常的问题。 2、【栅格处理-栅格更新相关】   修复了自身数据更新相关的函数&#xff08;例如 添加颜色映射表 等&#xff09;格式检查不通过的…
阅读更多...
【机器学习习题】估计一个模型在未见过的数据上的性能

【机器学习习题】估计一个模型在未见过的数据上的性能

您提到的不等式是统计学中的泛化误差界&#xff08;generalization error bound&#xff09;&#xff0c;它用于估计一个模型在未见过的数据上的性能。这个不等式是由Hoeffding不等式和Union Bound组合而成的。在这个不等式中&#xff0c;我们有以下符号&#xff1a; - P[|E_i…
阅读更多...
什么是 Microsoft Office 365？ Excel on Cloud 的好处

什么是 Microsoft Office 365？ Excel on Cloud 的好处

什么是Office 365 Office 365 是 Microsoft 的一套程序&#xff0c;可以在本地运行&#xff0c;也可以同步到云存储。 可以从访问程序。 借助 Office 365&#xff0c;您可以在任何地方进行工作&#xff0c;并与世界各地的同事共享工作文档。 Office 365 支持的设备&#xff1a…
阅读更多...
SpringBoot+若依+图片导出

SpringBoot+若依+图片导出

前言 本文基于若依框架&#xff0c;实现excel中图片导出功能。 自定义导出Excel数据注解 public enum ColumnType{NUMERIC(0), STRING(1), IMAGE(2);private final int value;ColumnType(int value){this.value value;}public int value(){return this.value;}} 工具类中设置…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023