lgcgkCQ

java 集合

1. 掌握容器的概念和体系结构

在Java当中，如果有一个类专门用来存放其它类的对象，这个类就叫做容器，或者就叫做集合，集合就是将若干性质相同或相近的类对象组合在一起而形成的一个整体

其中淡绿色的表示接口，红色的表示我们经常使用的类。

分类:

1.Collection:个独立元素的序列，这些元素都服从一条或多条规则。其中List必须按照插入的顺序保存元素、Set不能有重复的元素、Queue按照排队规则来确定对象的产生顺序（通常也是和插入顺序相同）

2.Map:一组成对的值键对对象，允许用键来查找值。ArrayList允许我们用数字来查找值，它是将数字和对象联系在一起。而Map允许我们使用一个对象来查找某个对象，它也被称为关联数组。或者叫做字典。

2. 掌握List接口以及List接口子类的底层数据结构

List接口实现了Collection接口. 所以List接口中包含了Collection接口的方法. 但是List接口还提供了两个重要的方法

方法：

1.get(int index): 获取指定索引位置的元素

2.set(int index,Object obj); 将集合中指定索引位置的对象修改为指定的对象.

实现类：

1.ArrayList：其底层是数组结构，ArrayList的查询速度很快，但是增删的速度较慢，与数组非常类似

ArrayList al = new ArrayList(); //创建ArrayList集合对象

al.add("aaa"); //添加字符串对象

al.add(111); //添加Integer包装类对象

al.add(false); //添加Boolean

al.add(33.88); //添加Double对象

al.add('a'); //添加Chracter对象

————————————————

2.LinkedList：其底层是链表结构，增删的速度快，但是查询的速度较慢，与链条结构有着类似之处

public class LinkedListDemo1 {

@SuppressWarnings({ "rawtypes", "unchecked" })

public static void main(String[] args) {

LinkedList ll = new LinkedList();

ll.add(111);

ll.add(222);

ll.add(333); //添加元素

ll.addFirst("aaa"); //在集合第一个位置添加元素

ll.addLast(888); //在集合最后一个位置添加元素

ll.removeFirst(); //移除集合中的第一个元素，如果集合为空，则返回异常

ll.removeLast(); //移除集合中的最后一个元素，如果集合为空，则返回异常

ll.clear(); //清空集合

say(ll.peekFirst()); //获取但不移除列表中的第一个元素，如果集合为空，返回null

say(ll.peekLast()); //获取但不移除列表中的最后一个元素，如果集合为空，返回null

say(ll.pollFirst()); //获取并移除此列表的第一个元素；如果此列表为空，则返回 null。

say(ll.pollLast()); //获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。

}

public static void say(Object obj) {

System.out.println(obj);

}

————————————————

3.vector：Vector底层是数组，这个类出现的比较早，在JDK1.0的时候就有了这个类。目前使用的比较少，其功能与ArrayList()类的功能一样，已被ArrayList类代替了

public class VectorDemo {

public static void main(String[] args) {

Vector vec = new Vector();

vec.add(111);

vec.add(222);

vec.add(333);

vec.add(444);

//枚举，可用于遍历集合中的元素

Enumeration enu = vec.elements();

while (enu.hasMoreElements()) {

Object obj = (Object) enu.nextElement();

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

}

System.out.println();

//用iterator()方法进行遍历

Iterator it = vec.iterator();

while(it.hasNext()) {

System.out.print(it.next() + " ");

}

枚举和迭代的输出结果是一样，可以说明两者的功能是一样的。因为枚举和方法名称过长，所以被换代器取代了

3. 掌握Set接口以及Set接口子类的的底层数据结构

一个不包含重复元素的 collection。

特点：不包含重复元素，无索引，无序。

方法：

1.HashSet：不保证 set 的迭代顺序，特别是它不保证该顺序恒久不变。HashSet如何保证元素唯一性，底层数据结构是哈希表，哈希表依赖于哈希值存储

依赖方法：

int hashCode()

boolean equals(Object obj)

2.LinkedHashSet：元素有序唯一，由链表保证元素有序，由哈希表保证元素唯一

3.TreeSet：使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法，TreeSet是如何保证元素的排序和唯一性的，底层数据结构是红黑树(红黑树是一种自平衡的二叉树) 。

4. 掌握HashMap的基本用法以及底层数据结构

实现原理：

HashMap的主干是一个Entry数组。Entry是HashMap的基本组成单元，每一个Entry包含一个key-value键值对。（其实所谓Map其实就是保存了两个对象之间的映射关系的一种集合）

用法：

public static void main(String[] args) {

HashMap< String, String> hMap =

new HashMap< String, String>();

hMap.put("1", "1st");

hMap.put("2", "2nd");

hMap.put("3", "3rd");

Collection cl = hMap.values();

Iterator itr = cl.iterator();

while (itr.hasNext()) {

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

}

继承体系：

5. 掌握TreeMap的基本用法以及底层数据结构

Java中的TreeMap用于存储与HashMap类非常相似的键值对。区别在于TreeMap提供了一种以排序顺序存储键/值对的有效方法。它是基于红黑树的NavigableMap实现。

继承体系：

功能：

1.它存储类似于HashMap的键值对。

2.它只允许不同的键。无法复制密钥。

3.它不能有null密钥但可以有多个null值。

4.它按排序顺序（自然顺序）或按Comparator地图创建时提供的密钥存储密钥。

5.它提供了有保证的log（n）的时间成本，为containsKey，get，put和remove操作。

6.它不同步。用于Collections.synchronizedSortedMap(new TreeMap())在并发环境中工作。

7.该iterator方法返回的迭代器是快速失败的。

方法：

void clear（）：它从地图中删除所有键值对。
void size（）：返回此映射中存在的键值对的数量。
void isEmpty（）：如果此映射不包含键 - 值映射，则返回true。
boolean containsKey（Object key）：'true'如果地图中存在指定的键，则返回。
布尔的containsValue（对象键）：它返回'true'如果一个指定的值被映射到地图上的至少一个键。
Object get（Object key）：它检索value指定的映射key，如果此映射不包含键的映射，则返回null。
Object remove（Object key）：它从地图中删除指定键的键值对（如果存在）。
比较器比较器（）：它返回用于对此映射中的键进行排序的比较器，如果此映射使用其键的自然顺序，则返回null。
Object firstKey（）：它返回树映射中当前的第一个（最少）键。
Object lastKey（）：它返回树映射中当前的最后一个（最大）键。
Object ceilingKey（Object key）：返回大于或等于给定键的最小键，如果没有这样的键则返回null。
Object higherKey（Object key）：返回严格大于指定键的最小键。
NavigableMap descendingMap（）：它返回此映射中包含的映射的逆序视图。

6. 掌握Iterator迭代器的迭代过程

原理：

迭代器（Iterator）是一种对象，它能够用来遍历标准模板库容器中的部分或全部元素，每个迭代器对象代表容器中的确定的地址。

通俗点说，迭代器表现的像指针，读取集合或者数组中的一个值，读完以后又指向下一条数据，一个个数过去。

功能比较简单，并且只能单向移动：

(1) 使用方法iterator() 要求容器返回一个Iterator 。第一次调用Iterator 的next() 方法时，它返回序列的第一个元素。注意：iterator() 方法是java.lang.Iterable 接口,被 Collection 继承。

(2) 使用next() 获得序列中的下一个元素。

(3) 使用hasNext() 检查序列中是否还有元素。

(4) 使用remove() 将迭代器新返回的元素删除。

Iterator 是 Java 迭代器最简单的实现，为 List设计的 ListIterator 具有更多的功能，它可以从两个方向遍历List ，也可以从List 中插入和删除元素

注意：

1.在迭代器迭代元素的过程中，不允许使用集合对象改变集合中的元素个数，如果需要添加或者删除只能使用迭代器的方法操作。

2.如果使用了集合对象改变集合中的元素个数那么就会报错：不改变个数即可，替换也可以的。

3.迭代器的生存周期为创建到使用结束的时段。

4. foreach : Iterator 的封装变形，变得比 Iterator更简单。但是他也需要知道数组或集合的类型。并且，Iterator 需要注意的，foreach 同样需要注意。

使用：

需要在迭代过程中对比元素并且将符合条件的元素从集合中移除，iterator的hashNext()可以知道是否有下一个元素,返回true或false，next()方法可以得到当前游标指向的元素,执行后会将游标指向下一个元素这一点很重要,你调用一次next()就会将游标向后移一次，remove()移除当前元素

List> maps = purchaseOrderItemMapper.queryByOrderId(orderId);

List> maps1 = purchaseStockInItemMapper.listData(orderId);

Iterator> iterator = maps.iterator();

Map next;

while (iterator.hasNext()){

next = iterator.next(); //一次循环只调用一次,控制下标,需要用元素的时抽取元素再对元素进行操作

for (Map m1 : maps1) {

if ((m1.get("materialModel").equals( next.get("materialModel"))) &&

(m1.get("stockNum").equals(next.get("num")))){

iterator.remove();

}

7. 了解ListIterator的特点和使用

ListIterator是一个功能更加强大的, 它继承于Iterator接口,只能用于各种List类型的访问。可以通过调用listIterator()方法产生一个指向List开始处的ListIterator, 还可以调用listIterator(n)方法创建一个一开始就指向列表索引为n的元素处的ListIterator。

定义：

Interface ListIterator{}

方法：

(1)双向移动（向前/向后遍历）.

(2)产生相对于迭代器在列表中指向的当前位置的前一个和后一个元素的索引.

(3)可以使用set()方法替换它访问过的最后一个元素.

(4)可以使用add()方法在next()方法返回的元素之前或previous()方法返回的元素之后插入一个元素.

使用：

import java.util.*;

public class TestListIterator{

public static void main(String[] args) {

ArrayList a = new ArrayList();

a.add("aaa");

a.add("bbb");

a.add("ccc");

System.out.println("Before iterate : " + a);

ListIterator it = a.listIterator()

while (it.hasNext()) {

System.out.println(it.next() + ", " + it.previousIndex() + ", " + it.nextIndex());

}

while (it.hasPrevious()) {

System.out.print(it.previous() + " ");

}

System.out.println();

it = a.listIterator(1);//调用listIterator(n)方法创建一个一开始就指向列表索引为n的元素处的ListIterator。

while (it.hasNext()) {

String t = it.next();

System.out.println(t);

if ("ccc".equals(t)) {

it.set("nnn");

} else {

it.add("kkk");

}

System.out.println("After iterate : " + a);

}

8. 了解Collections工具类

排序方法：

void reverse(List list)：反转

void shuffle(List list),随机排序

void sort(List list),按自然排序的升序排序

void sort(List list, Comparator c);定制排序，由Comparator控制排序逻辑

void swap(List list, int i , int j),交换两个索引位置的元素

void rotate(List list, int distance),旋转。当distance为正数时，将list后distance个元素整体移到前面。当distance为负数时，将 list的前distance个元素整体移到后面。

示例：

public class CollectionsTest {

public static void main(String[] args) {

ArrayList nums = new ArrayList();

nums.add(8);

nums.add(-3);

nums.add(2);

nums.add(9);

nums.add(-2);

System.out.println(nums);

Collections.reverse(nums);

System.out.println(nums);

Collections.sort(nums);

System.out.println(nums);

Collections.shuffle(nums);

System.out.println(nums);

//下面只是为了演示定制排序的用法，将int类型转成string进行比较

Collections.sort(nums, new Comparator() {

@Override

public int compare(Object o1, Object o2) {

// TODO Auto-generated method stub

String s1 = String.valueOf(o1);

String s2 = String.valueOf(o2);

return s1.compareTo(s2);

}

});

System.out.println(nums);

}

查找、替换方法：

int binarySearch(List list, Object key), 对List进行二分查找，返回索引，注意List必须是有序的

int max(Collection coll),根据元素的自然顺序，返回最大的元素。类比int min(Collection coll)

int max(Collection coll, Comparator c)，根据定制排序，返回最大元素，排序规则由Comparatator类控制。类比int min(Collection coll, Comparator c)

void fill(List list, Object obj),用元素obj填充list中所有元素

int frequency(Collection c, Object o)，统计元素出现次数

int indexOfSubList(List list, List target), 统计targe在list中第一次出现的索引，找不到则返回-1，类比int lastIndexOfSubList(List source, list target).

boolean replaceAll(List list, Object oldVal, Object newVal), 用新元素替换旧元素。

示例：

public class CollectionsTest {

public static void main(String[] args) {

ArrayList num = new ArrayList();

num.add(3);

num.add(-1);

num.add(-5);

num.add(10);

System.out.println(num);

System.out.println(Collections.max(num));

System.out.println(Collections.min(num));

Collections.replaceAll(num, -1, -7);

System.out.println(Collections.frequency(num, 3));

Collections.sort(num);

System.out.println(Collections.binarySearch(num, -5));

}

9. 了解Vector、Hashtable

Vector：

Vector是java.util包的类，他的功能是实现了一个动态增长的数组，像其他数组一样，此向量数组可以为每个包含的元素分配一下整数索引号，但是，向量不同于数组，它的长度可以在创建以后根据实际包含的元素个数增加或减少

Hashtable：

此类实现一个哈希表，该哈希表将键映射到相应的值。任何非 null 对象都可以用作键或值。为了成功地在哈希表中存储和获取对象，用作键的对象必须实现 hashCode 方法和 equals 方法。

10. 掌握泛型在集合中的用法

泛型：

泛型最常与集合使用，因为泛型最开始开始被加入Java就是为了解决集合向下转型一类问题的。如果我们有这样一个需求：定义一个描述类圆，要求圆中的数据类型是不确定的，也就是声名属性的时候，属性类型是不确定的。比如描述类圆中有半径，要求半径可以用int，也可以用double。那么此时数据类型不确定，就使用泛型，把数据类型参数化

List中使用：

在我们创建集合时使用<>来声明List集合只能保存Dog类对象

List dogs=new ArrayList<>();

创建Dog类对象

Dog dog1 = new Dog(“101”,“来福”);

添加Dog对象到集合中

dogs.add(dog1);//此时dogs集合中只能存放Dog类对象

Map中使用：

创建集合对象，key为String类型，value为Dog类类型。

Map dogs=new HashMap<>();

将dog对象保存到Map集合中

dogs.put(“111”, dog1);//此时的key只能是字符串类型，value只能是Dog类型

总结：

1.集合接口或集合类在jdk5.0时都修改为带泛型的结构。

2.在实例化集合类时，可以指明具体的泛型类型

3. 指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）使用到类的泛型的位置，都指定为实例化的泛型类型。

比如：add(E e) --->实例化以后：add(Integer e)

4.注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换

5.如果实例化时，没指明泛型的类型。默认类型为java.lang.Object类型。

11. 了解泛型的定义

定义：

泛型是一种数据类型，当我们不知道使用什么数据类型是，可以使用泛型。泛型也可以看出一个变量，用来接收数据类型。

格式：

修饰符 class 类名<代表泛型的变量> { //方法体 } //public boolean add(E e){ }

泛型接口和泛型方法

接口：权限修饰符 interface 接口名称<泛型>{}

实现类：权限修饰符 class 类名<泛型> implement 接口名<泛型>{},权限修饰符返回值类型方法名（泛型作为参数传递）

package _4泛型的概念和使用._4泛型的高级使用$泛型的受限$上限_下限;

import java.util.ArrayList;

import java.util.Collection;

/**

* @Author Admin

* @Classname DemoGeneric

* @Package _4泛型的概念和使用._4泛型的高级使用$泛型的受限$上限_下限

* @GreatDate 2020/04/17 21:56:07

* @Description TODO 泛型的高级使用，泛型的受限(上、下限限定)

泛型的受限

上限限定：? extends E；代表使用的泛型只能是E类型的子类/本身

下限限定：? super E：代表使用的泛型只能是E类型的父类/本身

public class DemoGeneric {

public static void main(String[] args) {

Collection list1 = new ArrayList();

Collection list2 = new ArrayList();

Collection list3 = new ArrayList();

Collection

java 集合

你可能感兴趣的:(Java)