Java基础之集合

Posted 2021-08-26 Ocean:)

集合

开发中使用数组的弊端

1. 数组中能够使用的方法非常少，功能方法需要程序员自己完成
2. 数据类型单一化，不支持多种情况
3. 数组容量定义之后不能改

集合的优势

1. 方法多样，功能完善
2. 数据类型多样化
3. 容量可变

集合架构

Java中集合的 总接口 Collection

Java中所有和集合有关的内容，都是Collection接口的子接口或者实现类

interface Collection<E>
	interface List<E>	List接口，有序可重复
		class ArrayList<E>	可变长度数组结构
		class LinkedList<E>	双向链表结构
		class Vector<E>	jdk1.0 线程安全的ArrayList，如果不考虑线程安全问题，推荐使用ArrayList
	
	interface Set<E>	Set接口，无序不可重复	
		HashSet<E>	底层存储数据方式采用哈希表
		TreeSet<E>	底层存储数据方式采用平衡二叉树

Collection接口下的常用方法

增:
    boolean add(E e);
	存入元素当前集合对象中，要求的数据类型是E类型，也就是泛型对应的具体数据类型
    boolean addAll(Collection<? extends E> c);
	括号中的内容就相当于 class Dog extends Animal中Dog被替换为?,? extends E泛型的上限
    要求存入的集合c中,存储的元素要么是E类型,要么是E类的子类

        
删:
	void clear();
	清空整个集合
    boolean remove(Object obj);
	删除集合中的指定元素
	boolean removeAll(Collection<?> c);
	删除两个集合的交集
	boolean retainAll(Collection<?> c);
	保留两个集合的交集

改
查:
	int size();
	返回集合中有效元素个数
	boolean isEmpty();
	判断当前集合是否为空
	boolean contains(Object obj);
	判断指定元素在当前集合中是否存在
	boolean containsAll(Collection<?> c);
	判断集合c是不是当前集合的子集合

实例

package cn.ocean888_b;

import java.util.ArrayList;
import java.util.Collection;

import javax.sound.midi.Soundbank;

public class Demo2 {
	public static void main(String[] args) {
		/*
		 * 因为Collection<E>使用一个接口，接口没有自己的类对象
		 * 需要使用Collection接口的实现类来完成演示过程ArrayList<E>
		 * 这里就用到了泛型
		 */
		Collection<String> c = new ArrayList<String>();
		
		c.add("one");
		c.add("two");
		c.add("three");
		c.add("four");
		
		System.out.println(c);
		
		Collection<String> c1 = new ArrayList<String>();
		c1.add("first");
		c1.add("second");
		c1.add("thrid");
		c1.add("forth");
		
		System.out.println(c1);
		c.addAll(c1);
		System.out.println(c);
		System.out.println("size:" + c.size());
		System.out.println(c.isEmpty());
		System.out.println(c.containsAll(c1));
		System.out.println(c.contains("forth"));
	}
}

迭代器

通过集合对象获取对应的Iterator迭代器

​ Iterator iterator

• 常用方法:

  boolean hasNext();

  ​ 判断当前Iterator是否可以继续运行

  E next()

  ​ 获取Iterator当前指向元素,并且指向下一个元素

  void remove();

  ​ 删除next获取的元素

  ​ 注意:remove方法仅能删除next获取的元素,并且时紧挨着使用

List集合接口特征和方法

特征：

​ 有序，可重复

​ 有序：添加顺序和存储顺序一致

​ 可重复：相同元素可以同时添加

​ List接口下的实现类，存在一定的下标操作机制

​ ArrayList底层数组形式操作，可以通过下标直接访问

​ LinkedList底层是一个双向链表结构

增：

• add(E e);

  ​ List接口下，当前方法是添加元素到集合的末尾，尾插法

• addAll(Collection<?extends E?> c);

  List接口下,当前方法是添加另一个集合到当前集合末尾,要求添加的集合中保存的元素和当前集合保存元素一致,或者是当前集合保存元素的子类

• add(int index, E e);

  在指定的下标位置，添加指定元素

• addAll(int index, Collection<?extends E?> c);

  在指定的下标位置,添加指定的集合,集合要求同addAll方法

删：

• void clear();

  清空整个集合

• remove(Object obj);

  删除集合中的指定元素

• removeAll(Collection<?> c);

  删除集合中两个集合的交集

• retainAll(Collection<?> c);

  保留两个集合的交集

• remove(int index);

  删除集合中的指定下标的元素

改：

• E set(int index,E e);

  使用指定元素替换指定下标index的元素,返回值是被替换掉的元素

查：

• int size();

  有效元素个数

• boolean isEmpty();

  判断当前集合是否为空

• boolean contains(Object obj);

  判断集合中是否包含某个元素

• boolean containsAll(Collection<?> c);

  判断集合中是否包含某个子集

• int indexOf(Object obj);

  找出指定元素在集合中的第一次出现的位置

• int lastIndexOf(Object obj);

  找出指定元素在集合中最后一次出现的位置

• E get(int index);

  获取指定下标的元素

• List subList(int fromIndex, int endIndex);

  获取当前集合的子集合

实例:

package cn.ocean888;

import java.util.ArrayList;
import java.util.List;

public class Demo01 {
	public static void main(String[] args) {
		// 注意导包导入util的包		
		List<String> list = new ArrayList<String>();
		
		list.add("one");
		list.add("two");
		list.add("three");
		list.add("four");
		
		List<String> list2 = new ArrayList<String>();
		
		list2.add("1");
		list2.add("2");
		list2.add("3");
		list2.add("4");
		
		System.out.println(list);
		list.addAll(2, list2);
		System.out.println(list.remove(3));
		System.out.println(list);
		
		String str = list.set(2, "2");
		System.out.println(str);
		System.out.println(list);
		
		list.add(3, "1");
		list.add(4, "2");
		System.out.println(list);
		int index = list.indexOf("2");
		System.out.println(index);
		
		int lastIndex = list.lastIndexOf("2");
		System.out.println(lastIndex);
		
		// lastList
		// java中所有的范围约束都是左闭右开，要头不要尾
		List<String> subList = list.subList(0, 5);
		System.out.println(subList);
		
	}
}

ArrayList可变长度数组

特征:

​ 数组形式的操作方式,查询效率高,但是删除,增加效率低

数组:

​ Object类型数组

方法:

​ ArrayList使用的方法基本上都是从List接口中遵从实现的方法

• 特征:

  ensureCapacity(int minCapacity);

  ​ 判断当前容量是否足够

  trimTosize();

  ​ 截断整个数组容量 => size有效元素个数

性能问题

线性表

• 增删慢
  • 增加元素有可能需要调用grow方法，对数组进行扩容，操作工程中需要大量的移动和拷贝过程，浪费时间
  • 在某一个位置添加删除元素，后边的元素位置都需要移动
• 查询快

计算机内地址查询采用基地址加偏移量的方式

null:

null ==> 0x内存中编号为0的地址

该地址收到系统保护，任何程序读取，写入0x0地址，系统将直接杀死程序

一般用于开发中初始化引用数据类型的变量，利用null报错，NullPointerException

debug

先下断点

f5，进入函数，单步调试

f6，不进入函数，跳步

LinkedList链表

底层是一个双向链表

特征：

• 增删快
  • 不涉及数据的移动，仅更改指针，速度快
• 查找慢
  • 需要从链表的开始位置一个一个节点跳转查询，速度慢

LinkedList使用的方法，大部分都是从List接口中遵从实现的方法

节点

• 向前的引用prev
• 存储元素的引用data
• 向后的引用next

class Node {   private Node prev;
    private Node next;
    private E value;
}

特征