黑马程序员—JAVA基础——集合

最新推荐文章于 2023-07-24 23:36:20 发布

gxf13283606362

最新推荐文章于 2023-07-24 23:36:20 发布

阅读量350

点赞数

本文链接：https://blog.csdn.net/gxf13283606362/article/details/50066931

版权

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------

1、List集合：

A：概述：

List接口继承了Collection接口。List中的元素是按顺序存放的，可以有重复元素。

ArrayList类：实现数组的动态操作，线程不安全，执行效率比Vector高

Vector类：实现动态数组线程安全向量类

Stack类：表示后进先出的对象栈，是Vector类的子类，

B：构造方法：

Arraylist类的构造方法：

a：public ArrayList();//构造一个初始容量为10的列表

b：public ArrayList(Collection c);//构造一个包含指定集合Collection对象元素的列表

c：public ArrayList(int initialCapacity);//构造一个初始容量为指定值initialCapacity的列表

C： List集合的特有功能：

a：添加功能

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

b：获取功能

Object get(int index):获取指定位置的元素

c：列表迭代器

ListIterator listIterator()：List集合特有的迭代器

d：删除功能

Object remove(int index)：根据索引删除元素,返回被删除的元素

e：修改功能

Object set(int index,Object element):根据索引修改元素，返回被修饰的元素

Eg:

<span style="font-family:Arial Black;">public class ListDemo {

public static void main(String[] args) {

// 创建集合对象

List list = new ArrayList();

 

// 添加元素

list.add("hello");

list.add("world");

list.add("java");

 

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

// list.add(1, "android");//没有问题

// IndexOutOfBoundsException

// list.add(11, "javaee");//有问题

// list.add(3, "javaee"); //没有问题

// list.add(4, "javaee"); //有问题

 

// Object get(int index):获取指定位置的元素

// System.out.println("get:" + list.get(1));

// IndexOutOfBoundsException

// System.out.println("get:" + list.get(11));

 

// Object remove(int index)：根据索引删除元素,返回被删除的元素

// System.out.println("remove:" + list.remove(1));

// IndexOutOfBoundsException

// System.out.println("remove:" + list.remove(11));

 

// Object set(int index,Object element):根据索引修改元素，返回被修饰的元素

System.out.println("set:" + list.set(1, "javaee"));

 

System.out.println("list:" + list);

}

}</span>

D：注意：

由于ArrayList是动态数组，它可以自动地进行数组的扩容。如果元素的个数超过了 ArrayList的容量，它就会将当前的容量扩大1倍，并将原来的元素放到这个扩容以后的新的数组中。为了提高ArrayList的使用效率，可以使用trimToSize方法将 ArrayList的容量调整为当前的容量大小，以便释放多余的空间。

2、Set集合：

A：Set集合的特点

无序,唯一

B：HashSet集合

a：底层数据结构是哈希表(是一个元素为链表的数组)

b：哈希表底层依赖两个方法：hashCode()和equals()

执行顺序：首先比较哈希值是否相同

相同：继续执行equals()方法

返回true：元素重复了，不添加

返回false：直接把元素添加到集合

不同：就直接把元素添加到集合

c：如何保证元素唯一性的呢?

由hashCode()和equals()保证的

d：开发的时候，代码非常的简单，自动生成即可。

e：HashSet存储字符串并遍历

f：HashSet存储自定义对象并遍历(对象的成员变量值相同即为同一个元素)

C：TreeSet集合

a：底层数据结构是红黑树(是一个自平衡的二叉树)

b：保证元素的排序方式

(1)：自然排序(元素具备比较性)

让元素所属的类实现Comparable接口

(2)：比较器排序(集合具备比较性)

让集合构造方法接收Comparator的实现类对象

c：把我们讲过的代码看一遍即可

Eg：

<span style="font-family:Arial Black;">package cn.itcast_06;

import java.util.TreeSet;

/*

 * 需求：请按照姓名的长度排序

 */

public class TreeSetDemo {

public static void main(String[] args) {

// 创建集合对象

TreeSet<Student> ts = new TreeSet<Student>();

 

// 创建元素

Student s1 = new Student("zhangsan", 27);

Student s2 = new Student("lisi", 29);

Student s3 = new Student("wangwu", 23);

Student s4 = new Student("maliu", 27);

Student s5 = new Student("xiaoming", 22);

Student s6 = new Student("xioali", 40);

Student s7 = new Student("qiqin", 22);

Student s8 = new Student("laoshi", 29);

 

// 添加元素

ts.add(s1);

ts.add(s2);

ts.add(s3);

ts.add(s4);

ts.add(s5);

ts.add(s6);

ts.add(s7);

ts.add(s8);

 

// 遍历

for (Student s : ts) {

System.out.println(s.getName() + "---" + s.getAge());

}

}

}</span>

<span style="font-family:Arial Black;">/*

 * 如果一个类的元素要想能够进行自然排序，就必须实现自然排序接口

 */

public class Student implements Comparable<Student> {

private String name;

private int age;

 

public Student() {

super();

}

 

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 compareTo(Student s) {

// 主要条件 姓名的长度

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

// 姓名的长度相同，不代表姓名的内容相同

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

// 姓名的长度和内容相同，不代表年龄相同，所以还得继续判断年龄

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

return num3;

}

}</span>

3、Collection集合

Collection

|--List 有序,可重复

|--ArrayList

底层数据结构是数组，查询快，增删慢。

线程不安全，效率高

|--Vector

底层数据结构是数组，查询快，增删慢。

线程安全，效率低

|--LinkedList

底层数据结构是链表，查询慢，增删快。

线程不安全，效率高

|--Set 无序,唯一

|--HashSet

底层数据结构是哈希表。

如何保证元素唯一性的呢?

依赖两个方法：hashCode()和equals()

|--LinkedHashSet

底层数据结构是链表和哈希表

由链表保证元素有序

由哈希表保证元素唯一

|--TreeSet

底层数据结构是红黑树。

如何保证元素排序的呢?

自然排序

比较器排序

如何保证元素唯一性的呢?

根据比较的返回值是否是0来决定

Eg:

<span style="font-family:Arial Black;">package cn.itcast_04;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

/*

 * 需求：存储自定义对象并遍历Student(name,age)

 * 分析：

 *  A:创建学生类

 *  B:创建集合对象

 *  C:创建学生对象

 *  D:把学生对象添加到集合对象中

 *  E:遍历集合

 */

public class CollectionTest2 {

public static void main(String[] args) {

// 创建集合对象

Collection c = new ArrayList();

 

// 创建学生对象

Student s1 = new Student("张三", 25);

Student s2 = new Student("李四", 16);

Student s3 = new Student("王五", 20);

Student s4 = new Student();

s4.setName("马六");

s4.setAge(26);

// 把学生对象添加到集合对象中

c.add(s1);

c.add(s2);

c.add(s3);

c.add(s4);

c.add(new Student("赵七", 18)); // 匿名对象

// 遍历集合

Iterator it = c.iterator();

while (it.hasNext()) {

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

System.out.println(s.getName() + "---" + s.getAge());

}

}

}

package cn.itcast_04;

 

public class Student {

private String name;

private int age;

 

public Student() {

super();

}

 

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;

}

 

}</span>

4、针对Collection集合到底使用谁呢?

If(唯一吗?){

Set

if(排序吗?){

TreeSet

}else{HashSet

}

}else{

List

If(要安全吗?){

Vector

}else{

ArrayList或者LinkedList

}

查询多用：ArrayList

增删多用：LinkedList

如果你知道是Set，但是不知道是哪个Set，就用HashSet。

如果你知道是List，但是不知道是哪个List，就用ArrayList

如果你知道是Collection集合，但是不知道使用谁，就用ArrayList。

如果你知道用集合，就用ArrayList。

5、在集合中常见的数据结构

ArrayXxx：底层数据结构是数组，查询快，增删慢

LinkedXxx：底层数据结构是链表，查询慢，增删快

HashXxx：底层数据结构是哈希表。依赖两个方法：hashCode()和equals()

TreeXxx：底层数据结构是二叉树。两种方式排序：自然排序和比较器排序

6、Map类：

A：特点：

将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

B：Map和Collection的区别?

a：Map 存储的是键值对形式的元素，键唯一，值可以重复。夫妻对

b：Collection 存储的是单独出现的元素，子接口Set元素唯一，子接口List元素可重复。光棍

C：Map接口功能：

a：添加功能

b：删除功能

c：判断功能

d：获取功能

e：长度功能

D：Map集合的遍历

a：键找值

(1)：获取所有键的集合

(2)：遍历键的集合,得到每一个键

(3)：根据键到集合中去找值

b：键值对对象找键和值

(1)：获取所有的键值对对象的集合

(2)：遍历键值对对象的集合，获取每一个键值对对象

(3)：根据键值对对象去获取键和值

Eg：

<span style="font-family:Arial Black;">public class MapDemo {

public static void main(String[] args) {

// 创建集合对象

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

 

// 添加元素

// V put(K key,V value):添加元素。

// System.out.println("put:" + map.put("文章", "马伊俐"));

// System.out.println("put:" + map.put("文章", "姚笛"));

 

map.put("邓超", "孙俪");

map.put("黄晓明", "杨颖");

map.put("周杰伦", "蔡依林");

map.put("刘恺威", "杨幂");

 

// void clear():移除所有的键值对元素

// map.clear();

 

// V remove(Object key)：根据键删除键值对元素，并把值返回

// System.out.println("remove:" + map.remove("黄晓明"));

// System.out.println("remove:" + map.remove("黄晓波"));

 

// boolean containsKey(Object key)：判断集合是否包含指定的键

// System.out.println("containsKey:" + map.containsKey("黄晓明"));

// System.out.println("containsKey:" + map.containsKey("黄晓波"));

 

// boolean isEmpty()：判断集合是否为空

// System.out.println("isEmpty:"+map.isEmpty());

//int size()：返回集合中的键值对的对数

System.out.println("size:"+map.size());

 

// 输出集合名称

System.out.println("map:" + map);

}

}</span>

7、Collections

A：是针对集合进行操作的工具类

B：Collection和Collections的区别

a：Collection 是单列集合的顶层接口，有两个子接口List和Set

b：Collections 是针对集合进行操作的工具类，可以对集合进行排序和查找等

C：常见的几个小方法：

a：public static <T> void sort(List<T> list)

b：public static <T> int binarySearch(List<?> list,T key)

c：public static <T> T max(Collection<?> coll)

d：public static void reverse(List<?> list)

e：public static void shuffle(List<?> list)

Eg：

package cn.itcast_04;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.TreeSet;

* 思路：

* A:创建一个HashMap集合

* B:创建一个ArrayList集合

* C:创建花色数组和点数数组

* D:从0开始往HashMap里面存储编号，并存储对应的牌

* 同时往ArrayList里面存储编号即可。

* E:洗牌(洗的是编号)

* F:发牌(发的也是编号，为了保证编号是排序的，就创建TreeSet集合接收)

* G:看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)

<span style="font-family:Arial Black;">public class PokerDemo {

public static void main(String[] args) {

// 创建一个HashMap集合

HashMap<Integer, String> hm = new HashMap<Integer, String>();

 

// 创建一个ArrayList集合

ArrayList<Integer> array = new ArrayList<Integer>();

 

// 创建花色数组和点数数组

// 定义一个花色数组

String[] colors = { "♠", "♥", "♣", "♦" };

// 定义一个点数数组

String[] numbers = { "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q",

"K", "A", "2", };

 

// 从0开始往HashMap里面存储编号，并存储对应的牌,同时往ArrayList里面存储编号即可。

int index = 0;

 

for (String number : numbers) {

for (String color : colors) {

String poker = color.concat(number);

hm.put(index, poker);

array.add(index);

index++;

}

}

hm.put(index, "小王");

array.add(index);

index++;

hm.put(index, "大王");

array.add(index);

 

// 洗牌(洗的是编号)

Collections.shuffle(array);

 

// 发牌(发的也是编号，为了保证编号是排序的，就创建TreeSet集合接收)

TreeSet<Integer> fengQingYang = new TreeSet<Integer>();

TreeSet<Integer> linQingXia = new TreeSet<Integer>();

TreeSet<Integer> liuYi = new TreeSet<Integer>();

TreeSet<Integer> diPai = new TreeSet<Integer>();

 

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

if (x >= array.size() - 3) {

diPai.add(array.get(x));

} else if (x % 3 == 0) {

fengQingYang.add(array.get(x));

} else if (x % 3 == 1) {

linQingXia.add(array.get(x));

} else if (x % 3 == 2) {

liuYi.add(array.get(x));

}

}

 

// 看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)

lookPoker("张三", fengQingYang, hm);

lookPoker("李四", linQingXia, hm);

lookPoker("王五", liuYi, hm);

lookPoker("底牌", diPai, hm);

}

 

// 写看牌的功能

public static void lookPoker(String name, TreeSet<Integer> ts,

HashMap<Integer, String> hm) {

System.out.print(name + "的牌是：");

for (Integer key : ts) {

String value = hm.get(key);

System.out.print(value + " ");

}

System.out.println();

}

}</span>

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------

gxf13283606362

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员—JAVA基础——集合

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------1、List集合： A：概述： List接口继承了Collection接口。List中的元素是按顺序存放的，可以有重复元素。 ArrayList类：实现数组的动态操作，线程不安全，执行效率比Vec
复制链接

扫一扫