Java集合框架超详细笔记

2401_83704252

于 2024-04-02 12:59:00 发布

阅读量603

点赞数 13

分类专栏：程序员文章标签： java 笔记开发语言

本文链接：https://blog.csdn.net/2401_83704252/article/details/137266204

版权

程序员专栏收录该内容

440 篇文章 2 订阅

订阅专栏

给集合中添加字符串数据并遍历;

public static void main(String[] args) {

//创建一个集合对象

Collection c = new ArrayList();

//给集合中添加元素

c.add(“kaka”);

c.add(“hello”);

c.add(“java”);

//Object[] toArray();

//里面存储的字符串数据----相当于:Object[] objs = new String()

Object[] obj = c.toArray();

//遍历数组

for(int i = 0; i < obj.length; i++){

String s = (String)obj[i];

System.out.println(s + “—” + s.length());

}

3.3.1 Object[] toArray遍历案例_01

需求:有5个学生,都有姓名和年龄,现需要将5个学生存储到集合中,并遍历5个学生信息

1)定义一个学生类

2)创建集合对象 Collection

3)创建5个学生

5)将5个学生添加到集合中

6)将集合转换成Object[] toArray

7)遍历数组

//Student类

public class Student {

private String name;

private int age;

public Student() {

super();

// TODO Auto-generated constructor stub

}

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;

}

@Override

public String toString() {

return “Student [name=” + name + “, age=” + age + “]”;

}

public Student(String name, int age) {

super();

this.name = name;

this.age = age;

}

public static void main(String[] args) {

//创建集合对象

Collection c = new ArrayList();

//创建对象

Student s1 = new Student(“卡卡”,23);

Student s2 = new Student(“张三”,23);

Student s3 = new Student(“李四”,23);

Student s4 = new Student(“王五”,23);

Student s5 = new Student(“赵六”,23);

//集合中添加元素

c.add(s1);

c.add(s2);

c.add(s3);

c.add(s4);

c.add(s5);

//将集合转换为object[]数组

Object[] obj = c.toArray();

//遍历数组

for(int i = 0; i < obj.length; i++){

Student s = (Student)obj[i];

System.out.println(s.getName() + “—” +s.getAge());

}

3.4 集合的专有遍历方式_迭代器

迭代器遍历：

Iterator iterator():获取集合的迭代器(集合专用遍历方式)

Iterator:迭代器(接口)

Object next() :获取下一个元素------>是对 Object\[\] toArray()这个方法封装

（是通过ArrayList集合实现的(内部类)next()）

boolean hasNext():判断功能,判断是否有下一个元素

迭代器的使用步骤：

创建集合对象
给集合对象中添加元素
获取迭代器

3.1 判断当前迭代器是否有下一个可以遍历的元素

3.2 在获取下一个元素

public static void main(String[] args) {

//创建集合对象

Collection c = new ArrayList();

//给集合中添加字符串元素

c.add(“kaka”);

c.add(“hello”);

c.add(“java”);

//使用迭代器遍历

Iterator it = c.iterator();

while(it.hasNext()){

//向下转型

String s = (String)(it.next());

System.out.println(s + “—” + s.length());

}

3.4.1 迭代器遍历案例_02

需求:有5个学生,都有姓名和年龄,现需要将5个学生存储到集合中,并遍历5个学生信息

1)定义一个学生类

2)创建集合对象 Collection

3)创建5个学生

5)将5个学生添加到集合中

6)创建迭代器

7)利用迭代器遍历集合

学生类

public class Student {

private String name;

private int age;

public Student() {

super();

// TODO Auto-generated constructor stub

}

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;

}

@Override

public String toString() {

return “Student [name=” + name + “, age=” + age + “]”;

}

public Student(String name, int age) {

super();

this.name = name;

this.age = age;

}

public static void main(String[] args) {

//创建集合对象

Collection c = new ArrayList();

//创建对象

Student s1 = new Student(“卡卡”,23);

Student s2 = new Student(“张三”,23);

Student s3 = new Student(“李四”,23);

Student s4 = new Student(“王五”,23);

Student s5 = new Student(“赵六”,23);

//集合中添加元素

c.add(s1);

c.add(s2);

c.add(s3);

c.add(s4);

c.add(s5);

//迭代器

Iterator it = c.iterator();

//遍历

while(it.hasNext()){

Student s = (Student)(it.next());

System.out.println(s.getName() + “—” + s.getAge());

}

注：使用迭代器获取next()下一个元素的时候,一定看清楚集合存储的元素是什么类型,否则会出现ClassCaseException------>类型转换异常;

4. List接口与实现类

=================================================================================

4.1 List接口概述

有序的 collection,此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。

有序集合,改接口可精确控制每个元素的插入位置。通过整数索引访问元素，搜索列表中的元素。

特点：

有序、有下标、元素可重复。
继承了父接口提供的共性方法，同时定义了一些独有的与下标相关的操作方法。

4.1.1 存储字符串并遍历案例

public static void main(String[] args) {

//创建一个List集合对象

List list = new ArrayList();

//添加元素

list.add(“kaka”);

list.add(“hello”);

list.add(“world”);

list.add(“java”);

list.add(“kaka”);

//使用Collection的迭代器

Iterator it = list.iterator();

//遍历

while(it.hasNext()){

String s = (String)(it.next());

System.out.println(s + “—” + s.length());

}

4.2 List的集合特有功能

void add(int index,Object element):在指定的位置处添加元素

Object remove(int index):删除指定索引处的元素

Object get(int index):获取功能: 获取指定索引处的元素

Object set(int index,E element):在指定位置处,修改元素内容

ListIterator listIterator(): list集合的专有遍历方式:列表迭代器

public static void main(String[] args) {

//创建List集合对象

List list = new ArrayList();

//添加元素

list.add(“kaka”);

list.add(“hello”);

list.add(“world”);

list.add(“java”);

//在指定的位置处添加元素

list.add(2, “python”);

//删除指定索引处的元素

System.out.println(list.remove(2));//python

//获取指定索引处的元素

System.out.println(list.get(0));//kaka

//在指定位置处修改元素内容

System.out.println(list.set(0, “卡卡”));//kaka

System.out.println(“list:” +list);//[卡卡, hello, world, java]

}

4.2.1 get(int index)+size()相结合遍历案例_03

需求:有5个学生,都有姓名和年龄,现需要将5个学生存储到集合中,并遍历5个学生信息

1)定义一个学生类

2)创建集合对象 List

3)创建5个学生

5)将5个学生添加到集合中

6)get(int index)+size()相结合遍历

//学生类

public class Student {

private String name ;

private int age ;

public Student() {

super();

// TODO Auto-generated constructor stub

}

public Student(String name, int age) {

super();

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;

}

@Override

public String toString() {

return “Student [name=” + name + “, age=” + age + “]”;

}

//创建一个List集合对象

List list1 = new ArrayList();

//创建5个学生对象

Student s1 = new Student(“卡卡”,23);

Student s2 = new Student(“张三”,23);

Student s3 = new Student(“李四”,23);

Student s4 = new Student(“王五”,23);

Student s5 = new Student(“赵六”,23);

//get(int index)+size()相结合普通for循环

for(int x = 0 ; x < list.size() ; x ++) {

Student s =(Student)(list1.get(x)) ;

System.out.println(s.getName()+“—”+s.getAge());

}

4.3 列表迭代器_ ListIterator

ListIterator listIterator(): list集合的专有遍历方式:列表迭代器；

ListIterator:接口

正向遍历

boolean hasNext() :判断是否有下一个可以迭代的元素

Object next() :获取下一个元素

逆向遍历

boolean hasPrevious() :判断是否有上一个可以迭代的元素

Object previous() :获取上一个元素

public static void main(String[] args) {

//创建一个List集合

List list = new ArrayList();

//添加字符串元素

list.add(“kaka”);

list.add(“hello”);

list.add(“java”);

//获取列表迭代器

ListIterator lit = list.listIterator();

//遍历

while(lit.hasNext()) {

String s = (String)(lit.next()) ;

System.out.println(s);

}

System.out.println(“--------------------”);

//逆向遍历

while(lit.hasPrevious()) {

String s = (String)(lit.previous()) ;

System.out.println(s);

}

4.3.1 使用迭代器遍历的问题

如果使用迭代器遍历元素,就不能使用集合添加元素；

java.util.ConcurrentModificationException:并发修改异常 ;

4.3.1.1 使用迭代器遍历,迭代器添加元素

public static void main(String[] args) {

//创建一个List集合对象

List list = new ArrayList();

//集合存储三个元素

list.add(“hello”) ;

list.add(“world”) ;

list.add(“java”) ;

//由于Collection的Iterator迭代器没有添加功能的,所以列表迭代器

ListIterator lit = list.listIterator() ;

while(lit.hasNext()) {

String s = (String)(lit.next()) ;

//判断

if(“world”.equals(s)) {

//迭代器添加元素

lit.add(“javaee”);

}

System.out.println(“list:”+list);

4.3.1.2 使用集合遍历,集合添加元素

public static void main(String[] args) {

//创建一个List集合对象

List list = new ArrayList();

//集合存储三个元素

list.add(“hello”) ;

list.add(“world”) ;

list.add(“java”) ;

//普通for循环:get(int index) 和 size()方法先结合

for(int i = 0 ;i < list.size() ; i ++) {

//获取元素

String s = (String)(list.get(i)) ;

//判断

if(“world”.equals(s)) {

//使用集合添加

list.add(“javaee”) ;

}

System.out.println(“list:”+list);

}

4.4 集合的四种遍历方式案例

public static void main(String[] args) {

//创建ArrayList集合对象

ArrayList array = new ArrayList() ;

//给集合中添加元素

array.add(“kaka”) ;

array.add(“hello”) ;

array.add(“world”) ;

array.add(“java”) ;

//1:Object[] toArray遍历

Object[] objs = array.toArray() ;

for(int x = 0 ; x < objs.length ; x ++) {

String s = (String)(objs[x]) ;

System.out.println(s+“—”+s.length());

}

System.out.println(“-----------------------”);

//2:Collection的迭代器

Iterator it = array.iterator() ;

while(it.hasNext()) {

String s = (String)(it.next()) ;

System.out.println(s+“—”+s.length());

}

System.out.println(“-----------------------”);

//3:使用List集合的列表迭代器

ListIterator lit = array.listIterator() ;

while(lit.hasNext()) {

String s = (String)(lit.next()) ;

System.out.println(s+“—”+s.length());

}

System.out.println(“-----------------------”);

//4:Object get(int index) 和int size()方法相集合

for (int i = 0; i < array.size(); i++) {

String s = (String)(array.get(i)) ;

System.out.println(s+“—”+s.length());

}

4.5 List集合的三个子实现类的特点

ArrayList：

底层数据结构:数组----->查询快,增删慢

从线程角度考虑:此实现不是同步的---->线程不安全---->执行效率高!

LinkedList：

底层数据结构:链接列表(链表)---->查询慢,增删快

从线程角度考虑:此实现不是同步的----->线程不安全---->执行效率高!

Vector：

底层数据库结构:可增长的数组实现---->查询快.增删慢

线程方面: 线程安全—>同步----->执行效率低!

除多线程环境外,在需求中没有指定具体的集合---->都使用ArrayList ()

4.6 ArrayList集合

见4.4，4.5；

4.6.1 存储自定义对象并遍历

需求:有5个学生,都有姓名和年龄,现需要将5个学生存储到集合中,并遍历5个学生信息

1)定义一个学生类

2)创建集合对象 ArrayList

3)创建5个学生

5)将5个学生添加到集合中

6)创建迭代器

7)利用迭代器遍历集合

//学生类

public class Student {

private String name;

private int age;

public Student() {

super();

// TODO Auto-generated constructor stub

}

public Student(String name, int age) {

super();

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;

}

@Override

public String toString() {

return “Student [name=” + name + “, age=” + age + “]”;

}

public static void main(String[] args) {

//创建ArrayList集合对象

ArrayList array = new ArrayList();

//创建5个学生对象

Student s1 = new Student(“卡卡”,23);

Student s2 = new Student(“张三”,23);

Student s3 = new Student(“李四”,23);

Student s4 = new Student(“王五”,23);

Student s5 = new Student(“赵六”,23);

//集合中添加元素

array.add(s1);

array.add(s2);

array.add(s3);

array.add(s4);

array.add(s5);

//迭代器

Iterator it = array.iterator();

//遍历

while(it.hasNext()){

Student s = (Student)(it.next());

System.out.println(s.getName() + “—” + s.getAge());

}

4.6.2 案例：获取10个1-20之间的随机数，要求不能重复,使用ArrayList集合

public static void main(String[] args) {

ArrayLists();

}

private static void ArrayLists() {

ArrayList arr = new ArrayList<>();

Random r = new Random();

while(arr.size() != 10){

int number = r.nextInt(20)+1 ;

if(!arr.contains(number)){

arr.add(number) ;

}

System.out.println(“ArrayList版本：”);

//遍历

Iterator it = arr.iterator();

while(it.hasNext()){

Integer i = (Integer)(it.next());

System.out.print(i + “\t”);

}

4.7 Vector集合

见4.5

通过整数索引访问组件；

线程安全的类：StringBuffer 和 Vector

Vector类特有功能：

public void addElement(Object obj):给Vector集合中添加元素 ------->类似于add(Object obj)

public Object elementAt(int index):通过整数索引值获取指定元素内容---->类似于Object get(int index)

public Enumeration elements() :就是Vector集合的专有遍历方式:返回Enumeration接口(枚举元素)----->类似于:Iterator iterator()

Enumeration接口：

*   boolean hasMoreElements():判断枚举中是否存在元素

*   Object nextElement():获取下一个枚举元素

public static void main(String[] args) {

//创建Vector集合对象

Vector v = new Vector();

//给Vector集合中添加元素

v.add(“kaka”);

v.add(“hello”);

v.add(“world”);

v.add(“java”);

//通过整数索引值获取指定元素内容 + size()遍历Vector集合

for(int i = 0; i < v.size(); i++){

String s = (String)(v.elementAt(i));

System.out.println(s + “—” + s.length());

}

System.out.println(“------------”);

//特有遍历

Enumeration em = v.elements();

while(em.hasMoreElements()){

String s = (String)(em.nextElement());

System.out.println(s + “—” + s.length());

}

4.8 ListedList集合

见4.5

ListedList集合特有功能：

添加

public void addFirst(Object e):将指定元素始终在链表开头添加

public void addLast(Object e):将指定的元素在链表的末尾添加

获取

public Object getFirst() :获取链表的第一个元素

public Object getLast() :获取链表的最后一个元素

删除

public Object removeFirst():删除链表第一个元素

public Object removeLast() :删除链表最后一个元素

public static void main(String[] args) {

//创建一个LinkeList集合对象

LinkedList link = new LinkedList() ;

link.add(“hello”) ;

link.add(“world”) ;

link.add(“java”) ;

//将指定元素始终在链表开头添加

link.addFirst(“javaee”);

link.addFirst(“android”);

//将指定的元素在链表的末尾添加

link.addLast(“go”);

link.addLast(“R”);

//获取链表的第一个元素,返回被获取的元素

System.out.println(“getFirst():”+link.getFirst());//android

//获取链表的最后一个元素

System.out.println(“getLast():”+link.getLast());//R

//删除链表第一个元素

System.out.println(“removeFirst():”+link.removeFirst());//android

//删除链表最后一个元素

System.out.println(“removeLast():”+link.removeLast());//R

System.out.println(“link:”+link);//[javaee, hello, world, java, go]

}

4.8.1 利用ListedList 集合模拟栈结构特点_01

栈的特点:先进后出;

利用ListedList 中的 public void addFirst(Object e)方法，将指定元素始终在链表开头添加，实现模拟栈的结构特点；

public static void main(String[] args) {

//创建一个LinkedList集合

LinkedList link = new LinkedList() ;

//addFirst()添加

link.addFirst(“kaka”);

link.addFirst(“hello”);

link.addFirst(“java”);

//遍历

//使用迭代器

Iterator it = link.iterator();

while(it.hasNext()) {

String s = (String)(it.next()) ;

System.out.println(s);

}

4.8.2 利用ListedList 集合模拟栈结构特点_02

利用ListedList 中的 public void addFirst(Object e)方法，将指定元素始终在链表开头添加，在利用public Object removeFirst()方法，删除链表第一个元素；一加一删来实现模拟栈结构特点；

import java.util.LinkedList;

/**

自定义的栈集合类
@author 卡卡

public class MyStack {

private LinkedList link;

//定义无参构造

public MyStack(){

link = new LinkedList();

}

/**

添加

public void add(Object obj){

link.addFirst(obj);

}

/**

获取

public Object get(){

return link.removeFirst();

}

/**

判断

public boolean isEmpy(){

return link.isEmpty();

}

测试类

public class MyStackTest {

public static void main(String[] args) {

//创建MyStack对象

MyStack my = new MyStack();

//添加元素

my.add(“kaka”);

my.add(“hello”);

my.add(“world”);

while(!my.isEmpy()){

//获取元素

System.out.println(my.get());

}

4.9 List 案例_01

需求:在ArrayList存储了一些重复元素,去重ArrayList重复的元素!(字符串元素)

创建一个新集合的思想

创建一个ArrayList集合对象 array

给集合中添加很多重复元素

创建一个新的集合newArray

遍历以前的集合

判断新集合如果不包含这个元素，就将这个元素添加到新集合中

遍历新集合

public static void main(String[] args) {

//创建一个ArrayList集合

ArrayList arr = new ArrayList<>();

//给集合中添加重复元素

arr.add(“kaka”);

arr.add(“hello”);

arr.add(“world”);

arr.add(“java”);

arr.add(“kaka”);

arr.add(“hello”);

arr.add(“kaka”);

arr.add(“java”);

//创建一个新集合

ArrayList newArr = new ArrayList<>();

//遍历以前的元素

Iterator it = arr.iterator();

while(it.hasNext()){

//获取元素

String s = (String)(it.next());

//判断新集合如果不包含这个元素,添加到新集合中；

if(! newArr.contains(s)){

newArr.add(s);

}

//遍历新集合

Iterator itN = newArr.iterator();

while(itN.hasNext()){

String s = (String)(itN.next());

System.out.println(s);

}

4.10 List案例_02

需求:在ArrayList存储了一些重复元素,去重ArrayList重复的元素!(字符串元素)

不创建新集合，利用选择排序的思想

使用0索引对应的元素和后面索引的元素进行比较,如果后面的元素和前面元素一致,就将后面重复元素从集合删除掉----->remove(int index)

创建ArrayList集合对象

添加重复元素

利用选择排序的思想，删除重复的元素

遍历集合

public static void main(String[] args) {

//创建一个ArrayList集合

ArrayList arr = new ArrayList<>();

//给集合中添加重复元素

arr.add(“kaka”);

arr.add(“hello”);

arr.add(“world”);

arr.add(“java”);

arr.add(“kaka”);

arr.add(“hello”);

arr.add(“kaka”);

arr.add(“java”);

//利用选择排序的思想,将后面重复元素从集合删除掉

for(int i = 0 ;i < arr.size()-1 ;i ++) {

for(int j = i+1 ; j < arr.size(); j++) {

//如果后面元素和前面的元素重复了,删除后面元素,里面索引–

//通过角标获取集合元素内容get(int index)

if(arr.get(i).equals(arr.get(j))) {

//删除

arr.remove(j) ;

j – ;

}

//遍历集合

Iterator it = arr.iterator() ;

while(it.hasNext()) {

String s = (String)(it.next()) ;

System.out.println(s);

}

4.11 List案例_03

需求：使用ArrayList集合存储自定义对象Student并去重

1)定义一个学生类

2)创建集合对象 ArrayList

3)创建5个学生

5)将5个学生添加到集合中

6)创建迭代器

7)利用迭代器遍历集合

重点：重写equals方法

//学生类

public class Student {

private String name ;

private int age ;

public Student() {

super();

// TODO Auto-generated constructor stub

}

public Student(String name, int age) {

super();

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;

}

@Override

public String toString() {

return “Student [name=” + name + “, age=” + age + “]”;

}

@Override

public boolean equals(Object obj) { //Student s ;

if (this == obj)

return true;

if (obj == null)

return false;

if (getClass() != obj.getClass())//获取字节码文件对象: this.getClass

return false;

Student other = (Student) obj;

if (age != other.age) //比较当前学生类中成员信息

return false;

if (name == null) {

if (other.name != null)

return false;

} else if (!name.equals(other.name)) //String name

return false;

return true;

}

public static void main(String[] args) {

//创建ArrayList集合对象

ArrayList arr = new ArrayList<>();

//创建学生对象

//创建对象

Student s1 = new Student(“卡卡”,23);

Student s2 = new Student(“张三”,23);

Student s3 = new Student(“李四”,23);

Student s4 = new Student(“卡卡”,23);

Student s5 = new Student(“王五”,23);

Student s6 = new Student(“赵六”,23);

//添加到集合中

arr.add(s1);

arr.add(s2);

arr.add(s3);

arr.add(s4);

arr.add(s5);

arr.add(s6);

//创建一个新集合

ArrayList newArr = new ArrayList<>();

//遍历以前的集合

Iterator it = arr.iterator();

while(it.hasNext()){

Student s = (Student)(it.next());

if(!newArr.contains(s)){

newArr.add(s);

}

//遍历新的集合

Iterator it2 = newArr.iterator();

for(int i = 0; i < newArr.size();i++){

Student s = (Student)(newArr.get(i));

System.out.println(s.getName() + “—” +s.getAge());

}

5. Set集合与实现类

================================================================================

5.1 Set 概述

Set接口就是一个不包含重复元素的collection；全部继承自Collection中的方法；

特点：

无序、无下标、元素不可以重复

Set集合和List集合的区别：

List集合：有序的集合，存储和取出是一致的，它允许元素重复

Set集合：无序的集合，存储和取出不一致（不能保证该顺序恒久不变），它元素唯一的

public static void main(String[] args) {

//创建一个Set集合对象

Set set = new HashSet();

//添加元素

set.add(“hello”);

set.add(“java”);

set.add(“world”);

//增强for遍历

for(String s :set){

System.out.println(s);//java world hello

}

元素不能重复

5.2 Set集合中的子实现类

Set中的子实类包括HashSet、LinkedHashSet、TreeSet

5.2.1 HashSet类概述

HashSet集合的add方法跟HashMap集合的put有关系，将所有需要存入HashSet的值，直接保存在HashMap中，底层依赖于hashCode()、equals()方法。需要在自定义的类中重写hashCode()和equals方法()；

需求：使用HashSet集合存储自定义对象Student,保证元素唯一

//学生类

public class Student {

private String name;

private int age;

public Student() {

super();

// TODO Auto-generated constructor stub

}

public Student(String name, int age) {

super();

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;

}

@Override

public int hashCode() {

final int prime = 31;

int result = 1;

result = prime * result + age;

result = prime * result + ((name == null) ? 0 : name.hashCode());

//result = 31 * 29 + name的哈希值

return result;

}

@Override

public boolean equals(Object obj) {

if (this == obj)

return true;

if (obj == null)

return false;

if (getClass() != obj.getClass())

return false;

Student other = (Student) obj;

if (age != other.age)

return false;

if (name == null) {

if (other.name != null)

return false;

} else if (!name.equals(other.name))

return false;

return true;

}

@Override

public String toString() {

return “Student [name=” + name + “, age=” + age + “]”;

}

public static void main(String[] args) {

//创建一个HashSet集合对象

Set set = new HashSet();

//创建学生对象

Student s1 = new Student(“卡卡”,23);

Student s2 = new Student(“张三”,26);

Student s3 = new Student(“卡卡”,24);

Student s4 = new Student(“张三”,26);

Student s5 = new Student(“卡卡”,34);

//添加集合中

set.add(s1);

set.add(s2);

set.add(s3);

set.add(s4);

set.add(s5);

//增强for遍历

for(Student s : set){

System.out.println(s.getName()+“—”+s.getAge());

}

以上代码输出：

卡卡—23

卡卡—24

卡卡—34

张三—26

5.2.2 LinkedHashSet类概述

元素有序唯一，底层数据结构是链接列表和哈希表

链接列表: 来保证元素有序(存储和取出一致的)
哈希表: 来保证元素唯一性

节点形式单独存储数据，并可以指向下一个节点，通过顺序访问节点，可保留元素插入顺序；

public static void main(String[] args) {

//创建LinkedHashSet集合对象

LinkedHashSet link = new LinkedHashSet();

//添加元素

link.add(“hello”);

link.add(“kaka”);

link.add(“javaEE”);

link.add(“android”);

//遍历

for(String s : link){

System.out.println(s);

}

以上代码输出：

hello

kaka

javaEE

android

6 TreeSet 类概述（重）

===================================================================================

底层数据结构是红黑树一种自平衡的二叉树；

1). 实现了SortedSet接口，要求必须可以对元素排序,使用元素的自然顺序对元素进行排序。

2). 所有插入元素，必须实现Comparable接口，覆盖compareTo方法。

3). 根据compareTo方法返回0作为去重的依据

6.1 Red - Black - Tree 红黑树结构简述

红黑树一种自平衡的二叉查找树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。

public static void main(String[] args) {

//创建TreeSet集合对象

TreeSet ts = new TreeSet();

//add()添加

ts.add(20) ;

ts.add(18) ;

ts.add(23) ;

ts.add(22) ;

ts.add(17) ;

ts.add(24) ;

ts.add(19) ;

ts.add(18) ;

ts.add(24) ;

//遍历集合

for(Integer i : ts) {

System.out.print(i+" ");//17 18 19 20 22 23 24

}

遍历原理：拿上面的数字20,18,23,22,17,24,19,18,24来说：

存储元素：

添加元素时，第一个元素20作为根节点---->root
后面添加的元素都需要和根节点进行比较
如果比根节点小，作为根节点的左孩子（根节点左边的子节点）
如果比根节点打，作为根节点的右孩子（根节点右边的子节点）
如果元素相等，不会进入到红黑树的结构中

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PfUZvbcY-1592762980994)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200621231132497.png)]$

遍历元素：

使用中序遍历（左根右）

首先访问根节点的左孩子，如果这个左孩子仍然有左孩子继续访问，一直到没有左孩子的节点，输出该节点17；
依据中序遍历次序，输出17的父节点18,；
在输出18的右孩子19；
以节点18为大的左孩子输出完毕，在输出整个二叉树的根节点20；
依据中序遍历次序左根右，找到根节点20的右孩子23，因为23有左孩子所以输出23的左孩子22；
输出22的根节点23；
在输出23的右孩子24；
最终得到序列17,18,19,20,22,23,24

6.2 TreeSet 集合案例_按照学生的年龄从小到大排序

TreeSet集合存储自定义对象,并且主要条件按照学生年龄的长度(从小到大比较)

主要条件：年龄从小到大排序

次要条件：

长度如果一样,还需要比较姓名的内容

需要比较人的年龄是否一样

如果要使用自然排序,针对自定义,该自定义类必须实现Comparable接口
重写 compareTo(T s)方法对元素进行比较

public class Student implements Comparable{

private String name;

private int age;

public Student() {

super();

// TODO Auto-generated constructor stub

}

public Student(String name, int age) {

super();

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;

}

@Override

public String toString() {

return “Student [name=” + name + “, age=” + age + “]”;

}

@Override

public int compareTo(Student s) {

// TODO Auto-generated method stub

int num = this.age - s.age;

int num2 = (num == 0?(this.name.compareTo(s.name)):num);

return num2;

}

public static void main(String[] args) {

TreeSet ts = new TreeSet();

Student s1 = new Student(“kaka”,23);

Student s2 = new Student(“kaka”,21);

Student s3 = new Student(“kaaka”,28);

Student s4 = new Student(“kkkkaka”,26);

Student s5 = new Student(“ka11ka”,24);

Student s6 = new Student(“kakaaa”,23);

Student s7 = new Student(“kaka”,23);

//添加元素

ts.add(s1);

ts.add(s2);

ts.add(s3);

ts.add(s4);

ts.add(s5);

ts.add(s6);

ts.add(s7);

//遍历

for(Student s : ts){

System.out.println(s.getName()+“—”+s.getAge());

}

以上代码输出：

kaka—21

kaka—23

kakaaa—23

ka11ka—24

kkkkaka—26

kaaka—28

6.3 TreeSet 集合案例_按照学生的

姓名长度从小到大排序

学生类

public class Student implements Comparable {

private String name ;

private int age ;

public Student() {

super();

// TODO Auto-generated constructor stub

}

public Student(String name, int age) {

super();

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;

}

@Override

public String toString() {

return “Student [name=” + name + “, age=” + age + “]”;

}

//重写Comparable接口的方法

@Override

public int compareTo(Student s) {

//主要条件按照学生姓名的长度(从小到大)

int num = this.name.length() - s.name.length() ;

//1)次要条件:姓名的长度一样,姓名的内容不一定一样

int num2 = num == 0 ? (this.name.compareTo(s.name)) : num;

//2)次要条件:姓名的长度一样,内容一样,年龄不一定一样

int num3 = num2 == 0 ? (this.age-s.age) : num2 ;

return num3 ;

}

public static void main(String[] args) {

//创建一个TreeSet集合对象

TreeSet ts = new TreeSet() ; //实现自然排序

//创建学生对象

Student s1 = new Student(“kaka”,23);

Student s2 = new Student(“kaka”,21);

Student s3 = new Student(“kaaka”,28);

Student s4 = new Student(“kkkkaka”,26);

Student s5 = new Student(“ka11ka”,24);

Student s6 = new Student(“kakaaa”,23);

Student s7 = new Student(“kaka”,23);

ts.add(s1) ;

ts.add(s2) ;

ts.add(s3) ;

ts.add(s4) ;

ts.add(s5) ;

ts.add(s6) ;

ts.add(s7) ;

//增强for

for(Student s :ts) {

System.out.println(s.getName()+“—”+s.getAge());

}

以上代码输出：

kaka—21

kaka—23

kaaka—28

ka11ka—24

kakaaa—23

kkkkaka—26

6.4 TreeSet集合两种比较器排序

构造方法：

TreeSet():创建TreeSet集合对象使用自然排序

TreeSet(Comparator comparatpr):比较器排序

*   构造方法的形式参数是一个接口类型:

    1.  自定义类实现Comarator接口,重写compare(T o1 ,T o2)方法

    2.  接口的匿名内部类

        new 接口名(){

               重写接口中的方法;

};

注：6.4.1和6.4.2学生类都是以下

学生类

public class Student {

private String name;

private int age;

public Student() {

super();

// TODO Auto-generated constructor stub

}

public Student(String name, int age) {

super();

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;

}

@Override

public String toString() {

return “Student [name=” + name + “, age=” + age + “]”;

}

6.4.1 自定义类实现Comparator接口

Comparator接口

public class MyComparator implements Comparator{

public MyComparator() {

}

@Override

public int compare(Student s1, Student s2) {

//s1----->this

//s2---->传进来被比较的对象

//主要条件:按照学生年龄从小到大

int num = s1.getAge() - s2.getAge() ;

//次要条件：如果年龄一样,比较姓名的内容是否一样

int num2 = num == 0 ? (s1.getName().compareTo(s2.getName())) : num ;

return num2;

}

public static void main(String[] args) {

//创建一个TreeSet集合对象

//TreeSet(Comparator comparatpr):比较器排序

TreeSet ts = new TreeSet(new MyComparator()) ;

//创建几个学生对象

Student s1 = new Student(“kaka”,23);

Student s2 = new Student(“kaka”,21);

Student s3 = new Student(“kaaka”,28);

Student s4 = new Student(“kkkkaka”,26);

Student s5 = new Student(“ka11ka”,24);

Student s6 = new Student(“kakaaa”,23);

Student s7 = new Student(“kaka”,23);

//添加元素

ts.add(s1) ;

ts.add(s2) ;

ts.add(s3) ;

ts.add(s4) ;

ts.add(s5) ;

ts.add(s6) ;

ts.add(s7) ;

//遍历

for(Student s: ts) {

System.out.println(s.getName()+“—”+s.getAge());

}

以上代码输出：

kaka—21

kaka—23

kakaaa—23

ka11ka—24

kkkkaka—26

kaaka—28

6.4.2 直接接口的匿名内部类

public static void main(String[] args) {

//直接接口的匿名内部类

TreeSet ts = new TreeSet(new Comparator() {

@Override

public int compare(Student s1, Student s2) {

//s1----->this

//s2---->传进来被比较的对象

//主要条件:按照学生年龄从小到大

int num = s1.getAge() - s2.getAge() ;

//次要条件：如果年龄一样,比较姓名的内容是否一样

int num2 = num == 0 ? (s1.getName().compareTo(s2.getName())) : num ;

return num2;

}

});

//创建几个学生对象

Student s1 = new Student(“kaka”,23);

Student s2 = new Student(“kaka”,21);

Student s3 = new Student(“kaaka”,28);

Student s4 = new Student(“kkkkaka”,26);

Student s5 = new Student(“ka11ka”,24);

Student s6 = new Student(“kakaaa”,23);

Student s7 = new Student(“kaka”,23);

//添加元素

ts.add(s1) ;

ts.add(s2) ;

ts.add(s3) ;

ts.add(s4) ;

ts.add(s5) ;

ts.add(s6) ;

ts.add(s7) ;

//遍历

for(Student s: ts) {

System.out.println(s.getName()+“—”+s.getAge());

}
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

总结

对于面试，一定要有良好的心态，这位小伙伴面试美团的时候没有被前面阿里的面试影响到，发挥也很正常，也就能顺利拿下美团的offer。
小编还整理了大厂java程序员面试涉及到的绝大部分面试题及答案，希望能帮助到大家，

在这里插入图片描述

最后感谢大家的支持，希望小编整理的资料能够帮助到大家！也祝愿大家都能够升职加薪！
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！
erride

public String toString() {

return “Student [name=” + name + “, age=” + age + “]”;

}

6.4.1 自定义类实现Comparator接口

Comparator接口

public class MyComparator implements Comparator{

public MyComparator() {

}

@Override

public int compare(Student s1, Student s2) {

//s1----->this

//s2---->传进来被比较的对象

//主要条件:按照学生年龄从小到大

int num = s1.getAge() - s2.getAge() ;

//次要条件：如果年龄一样,比较姓名的内容是否一样

int num2 = num == 0 ? (s1.getName().compareTo(s2.getName())) : num ;

return num2;

}

public static void main(String[] args) {

//创建一个TreeSet集合对象

//TreeSet(Comparator comparatpr):比较器排序

TreeSet ts = new TreeSet(new MyComparator()) ;

//创建几个学生对象

Student s1 = new Student(“kaka”,23);

Student s2 = new Student(“kaka”,21);

Student s3 = new Student(“kaaka”,28);

Student s4 = new Student(“kkkkaka”,26);

Student s5 = new Student(“ka11ka”,24);

Student s6 = new Student(“kakaaa”,23);

Student s7 = new Student(“kaka”,23);

//添加元素

ts.add(s1) ;

ts.add(s2) ;

ts.add(s3) ;

ts.add(s4) ;

ts.add(s5) ;

ts.add(s6) ;

ts.add(s7) ;

//遍历

for(Student s: ts) {

System.out.println(s.getName()+“—”+s.getAge());

}

以上代码输出：

kaka—21

kaka—23

kakaaa—23

ka11ka—24

kkkkaka—26

kaaka—28

6.4.2 直接接口的匿名内部类

public static void main(String[] args) {

//直接接口的匿名内部类

TreeSet ts = new TreeSet(new Comparator() {

@Override

public int compare(Student s1, Student s2) {

//s1----->this

//s2---->传进来被比较的对象

//主要条件:按照学生年龄从小到大

int num = s1.getAge() - s2.getAge() ;

//次要条件：如果年龄一样,比较姓名的内容是否一样

int num2 = num == 0 ? (s1.getName().compareTo(s2.getName())) : num ;

return num2;

}

});

//创建几个学生对象

Student s1 = new Student(“kaka”,23);

Student s2 = new Student(“kaka”,21);

Student s3 = new Student(“kaaka”,28);

Student s4 = new Student(“kkkkaka”,26);

Student s5 = new Student(“ka11ka”,24);

Student s6 = new Student(“kakaaa”,23);

Student s7 = new Student(“kaka”,23);

//添加元素

ts.add(s1) ;

ts.add(s2) ;

ts.add(s3) ;

ts.add(s4) ;

ts.add(s5) ;

ts.add(s6) ;

ts.add(s7) ;

//遍历

for(Student s: ts) {

System.out.println(s.getName()+“—”+s.getAge());

}
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-KVINaJug-1712033898566)]

[外链图片转存中…(img-Qh1aO6py-1712033898567)]

[外链图片转存中…(img-I1K7tfFk-1712033898567)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

总结

[外链图片转存中…(img-CvuR2vgs-1712033898568)]

[外链图片转存中…(img-X44nCUDB-1712033898568)]

最后感谢大家的支持，希望小编整理的资料能够帮助到大家！也祝愿大家都能够升职加薪！
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！

2401_83704252

关注

13
点赞
踩
21

收藏

觉得还不错? 一键收藏
0
评论
Java集合框架超详细笔记

需求:有5个学生,都有姓名和年龄,现需要将5个学生存储到集合中,并遍历5个学生信息1)定义一个学生类2)创建集合对象 ArrayList3)创建5个学生5)将5个学生添加到集合中6)创建迭代器7)利用迭代器遍历集合//学生类super();super();return age;@Override//创建ArrayList集合对象//创建5个学生对象Student s1 = new Student(“卡卡”,23);
复制链接

扫一扫