数组与集合

最新推荐文章于 2020-12-19 18:13:57 发布

rxl2017

最新推荐文章于 2020-12-19 18:13:57 发布

阅读量221

点赞数

分类专栏： J2SE 文章标签： JAVA基础

本文链接：https://blog.csdn.net/rxl2017/article/details/84147650

版权

J2SE 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

数组

数组：其实就是定义一个可以存储多个数据的容器，也称为实体。实体的定义需要使用一个关键字来完成。就是new。要明确这个实体中存储的元素的类型，和元素的个数 .
1、数组的定义形式：
元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
元素类型[] 数组名 ={1,2,3,4,5,6,7};可以直接指定具体的数据
元素类型[] 数组名；
数组名 = new 元素类型[元素个数或数组长度];
2、数组的特点：
1）数组定义时，必须明确数组的长度(就是数组中可以存储的元素的个数。)因为数组长度是固定的。
2）数组定义时，必须明确数组中的元素的数据类型。
3.数组常见的问题：
ArrayIndexOutOfBoundsException:数组的角标越界异常
当访问到了数组中不存在的角标时，就会发生该异常。
NullPointerException 空指针异常。
当一个引用型变量没有任何实体指向时，还在使用实体中的内容。就会发生该异常。System.out.println(arr);// [I@c17164 @前面的字母表示数据类型，[[I@69dfe453 代表二维数组，后面则以此类推
4.内存分布

当然每次 new 出来的内存地址不同

package base_data;

public class Array {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int IntArray[] = new int[3];
		System.out.println(IntArray); //[I@17b68215 内存地址，实际上是数组的头（xxx[0])的地址
		System.out.println(IntArray[0]);// 0,int 类型数组的初始化都是0；
		
		char CharArrary[] = {'1','2','3'};//字符类型的数组就是String的底层实现，如果为空的话，JAVA控制台会直接输出为空，效果表现如下 
		                                  //String string = new String();
                                          //System.out.println(string);//为空
		System.out.println(CharArrary);//123
		System.out.println(CharArrary[0]);//1
		
		boolean booleanArray[] = new boolean[3];
		System.out.println(booleanArray);//[Z@3cf5b814，同样是内存地址
		System.out.println(booleanArray[1]);//false,初始化为false
		
		float floatArray[] = new float [3];
		System.out.println(floatArray);//[F@8523ca2
		System.out.println(floatArray[0]);//0.0，后面全为0的情况下只展示0.0
		
		double doubleArray[] = new double [3];
		System.out.println(doubleArray);//[D@69dfe453
		System.out.println(doubleArray[0]);//0.0,虽然是双精度，但是和单精度一样，后面全为0的情况下只展示0.0
		
		
		
	}

}

二维数组：

常见的二维数组的定义形式：
1、 int[][] arr = new int[3][3];
2、 int[][] arr = new int[3][]; //定义一个二维数组，明确了二维数组的长度，但是二维中的每一个一位数组没有明确
    arr[0]=new int[3];
	arr[1]=new int[2];
	arr[2]=new int[5];
3、 int[] arr[] = new int[3][3];
4、 int arr[][] = new int[3][3];
5、 int[][] arr = {{1,3,5,6},{6,3,2},{1,2}};

什么时候使用二维数组：当数组多了就可以采用二维数组来继续存储。
中括号随着类型定义对所有变量都起作用，如果中括号在变量后面只对当前的变量起作用。

package base_data;

public class DoubleArray {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		// 数组中的数组：数组中的元素还是数组。

		int[][] arr = new int[2][3];//2x3的二维表结构

		System.out.println(arr[0][1]);// 0
		System.out.println(arr[0]);// [I@c17164
		System.out.println(arr);// [[I@c17164

		int[][] arr1 = new int[3][];// 定义一个二维数组，明确了二维数组的长度，
		// 但是二维中每一个一维数组并没有明确。

		// 对二位数组中的每一个一维数组进行初始化。大小可以不同,也可以为null

		arr1[0] = new int[3];
		arr1[1] = new int[1];
		arr1[2] = null;
		System.out.println(arr1);// [[I@c17164
		System.out.println(arr1[0]);// [I@8523ca2

	}

}

集合

如果说，封装类是基础数据类型的封装，那么集合便是数组的封装。集合的底层也是由线性数组和链性数组或者二者结合实现的。集合的特点：
1、集合是一个容器（里面装着数组或者链表）
2、集合用于存放对象（其实存放着对象的引用，也可以存放基础数据类型，因为JDK1.5以后有着自动装箱和拆箱功能），放在里面的对象会向上转型为Object，引用的里面的对象则会直接转出为Object，这个时候我们就需要泛型了。类似于这样：

List<Integer> list = new ArrayList<Integer>();//保证每个元素都是Integer,且每次引用时会自动转型成Integer

3.集合的长度可变，类似LinkedList这种底层是链表的我就不多说了，那么底层为线性数组的ArrayList是如何实现的呢，首先，如果在初始化ArrayList的时候没有申明长度，则数组默认长度为10，当调用add方法往里面添加元素时，会检查size+1是否超过数组的长度，如果超出则会重新NEW一个新数组，长度为前一个数组的长度的1.5倍并将原数组复制到新数组。（我们都知道，频繁的创建是一个极其消耗性能的事情，那么如果我们要导入10000条数据到ArrayList怎们办呢？自然是类似于这样：List list = new ArrayList（10000）;）

说完集合的特点，我们来谈谈JAVA集合本身有哪些类。

在学习Java中的集合类的API、编程原理的时候，我们一定要明白，"集合"是一个很古老的数学概念，它远远早于Java的出现。从数学概念的角度来理解集合能帮助我们更好的理解编程中什么时候该使用什么类型的集合类。

Java容器类类库的用途是"保存对象"，并将其用接口划分为两个不同的概念：

Collection
（Interface 迭代器接口，这是Collection类的父接口。实现这个Iterable接口的对象允许使用foreach进行遍历，也就是说，所有的Collection集合对象都具有"foreach可遍历性"。这个Iterable接口只有一个方法: iterator()。它返回一个代表当前集合对象的泛型迭代器，用于之后的遍历操作）
　　1.1) List必须保持元素特定的顺序
　　1.2) Set不能有重复元素
Map
一组成对的"键值对"对象

以下是详细介绍：

1.Collection

Collection是最基本的集合接口，一个Collection代表一组Object的集合，这些Object被称作Collection的元素。Collection是一个接口，用以提供规范定义，不能被实例化使用
Collection子体系特有的方法：

添加

boolean add(E e)
确保此 collection 包含指定的元素。
boolean addAll(Collection<? extends E> c)
将指定 collection 中的所有元素都添加到此 collection 中。

删除

boolean remove(Object o)
从此 collection 中移除指定元素的单个实例，如果存在的话。
boolean removeAll(Collection<?> c)
移除此 collection 中那些也包含在指定 collection 中的所有元素。
boolean retainAll(Collection<?> c)
仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）
void clear()
移除此 collection 中的所有元素。

查询

boolean contains(Object o)
如果此 collection 包含指定的元素，则返回 true。
boolean containsAll(Collection<?> c)
如果此 collection 包含指定 collection 中的所有元素，则返回 true。
boolean isEmpty()
如果此 collection 不包含元素，则返回 true。
Iterator iterator()
返回在此 collection 的元素上进行迭代的迭代器。
。 int size()
返回此 collection 中的元素数。

转型

Object[] toArray()
返回包含此 collection 中所有元素的数组。
T[] toArray(T[] a)
返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

1.1 List

List集合代表一个元素有序、可重复的集合，集合中每个元素都有其对应的顺序索引。List集合允许加入重复元素，因为它可以通过索引来访问指定位置的集合元素。List集合默认按元素的添加顺序设置元素的索引
List 子体系中的特有方法：

添加

boolean addAll(int index, Collection<? extends E> c)
将指定 collection 中的所有元素都插入到列表中的指定位置。

删除

object remove(index);
删除指定索引上的元素，并返回该元素

查询

object get(int index)
返回列表中指定位置的元素
int indexOf(Object o)
返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
int lastIndexOf(Object o)
返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
List subList(int fromIndex, int toIndex)
返回列表中指定的 fromIndex（包括）和 toIndex（不包括）之间的部分视图。

修改

Object set(int index, Object o)
用指定元素替换列表中指定位置的元素，并返回以前在指定位置的元素。

迭代器

除了Collection固有的iterator()方法，List还额外提供了一个listIterator()方法，该方法返回一个ListIterator对象，ListIterator接口继承了Iterator接口，提供了专门操作List的方法。ListIterator接口在Iterator接口的继承上增加了如下方法:

boolean hasPrevious(): 返回该迭代器关联的集合是否还有上一个元素
Object previous(): 返回该迭代器的上一个元素(向前迭代)
void add(): 在指定位置插入一个元素

1.1.1 ArrayList

ArrayList是基于数组实现的List类，它封装了一个动态的增长的、允许再分配的Object[]数组。
ArrayList类中的特有方法：

对容量的操作

void trimToSize()
将此 ArrayList 实例的容量调整为列表的当前大小。
void ensureCapacity(int minCapacity)
如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。（会在类似new ArrayList(10000)中调用，如果不传参则默认为10）

1.1.2 LinkedList

implements List, Deque。实现List接口，能对它进行队列操作，即可以根据索引来随机访问集合中的元素。同时它还实现Deque接口，即能将LinkedList当作双端队列使用。自然也可以被当作"栈来使用"，底层数据结构是链表数据结构。
LinkedList类中的特有方法：

添加

void addFirst( Object o)
将指定元素插入此列表的开头。
void addLast( Object o)
将指定元素添加到此列表的结尾。
boolean offer( Object o)
将指定元素添加到此列表的末尾（最后一个元素）。
boolean offerFirst( Object o)
在此列表的开头插入指定的元素。
boolean offerLast( Object o)
在此列表末尾插入指定的元素。

删除

Object remove()
获取并移除此列表的头（第一个元素）。如果此列表为空抛出NoSuchElementException
Object removeFirst()
移除并返回此列表的第一个元素。如果此列表为空抛出NoSuchElementException
Object removeLast()
移除并返回此列表的最后一个元素。如果此列表为空抛出NoSuchElementException
boolean removeLastOccurrence(Object o)
从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。

开发中建议使用poll

Object poll()
获取并移除此列表的头（第一个元素）
Object pollFirst()
获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
E pollLast()
获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。

查询

Object getFirst()
返回此列表的第一个元素。如果集合中没有元素，会抛出 NoSuchElementException
Object getLast()
返回此列表的最后一个元素。如果集合中没有元素，会抛出 NoSuchElementException

开发中建议使用peek

Object peek()
获取但不移除此列表的头（第一个元素）。
Object peekFirst()
获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
Object peekLast()
获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。

1.2 Set

一个不包含重复元素的 collection。更正式地说，set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素
Set 子体系中的特有方法：

添加

boolean add(E e)
如果 set 中尚未存在指定的元素，则添加此元素。
boolean addAll(Collection<? extends E> c)
如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中。

1.2.1 HashSet

HashSet是Set接口的典型实现，HashSet使用HASH算法来存储集合中的元素，因此具有良好的存取和查找性能。当向HashSet集合中存入一个元素时，HashSet会调用该对象的 hashCode()方法来得到该对象的hashCode值，然后根据该HashCode值决定该对象在HashSet中的存储位置。
值得注意的是，HashSet集合判断两个元素相等的标准是两个对象通过equals()方法比较相等，并且两个对象的hashCode()方法的返回值相等

1.2.2 TreeSet

TreeSet是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态
TreeSett类中的特有方法：

查询

E first()
返回此 set 中当前第一个（最低）元素。
E last()
返回此 set 中当前最后一个（最高）元素。
E ceiling(E e)
返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null。
E higher(E e)
返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null。
E floor(E e)
返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null。
E lower(E e)
返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 null。
NavigableSet subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive)
返回此 set 的部分视图，其元素范围从 fromElement 到 toElement。
SortedSet subSet(E fromElement, E toElement)
返回此 set 的部分视图，其元素从 fromElement（包括）到 toElement（不包括）。
SortedSet tailSet(E fromElement)
返回此 set 的部分视图，其元素大于等于 fromElement。
NavigableSet tailSet(E fromElement, boolean inclusive)
返回此 set 的部分视图，其元素大于（或等于，如果 inclusive 为 true）fromElement。
NavigableSet descendingSet()
返回此 set 中所包含元素的逆序视图。

删除

E pollFirst()
获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。
E pollLast()
获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。

迭代器

Iterator descendingIterator()
返回在此 set 元素上按降序进行迭代的迭代器。

2.Map

Map用于保存具有"映射关系"的数据，因此Map集合里保存着两组值，一组值用于保存Map里的key，另外一组值用于保存Map里的value。key和value都可以是任何引用类型的数据。Map的key不允许重复，即同一个Map对象的任何两个key通过equals方法比较结果总是返回false。
关于Map，我们要从代码复用的角度去理解，java是先实现了Map，然后通过包装了一个所有value都为null的Map就实现了Set集合
Map的这些实现类和子接口中key集的存储形式和Set集合完全相同(即key不能重复)
Map的这些实现类和子接口中value集的存储形式和List非常类似(即value可以重复、根据索引来查找)
Map 子体系中的特有方法：

添加

V put(K key, V value)
将指定的值与此映射中的指定键关联，返回以前与 key 关联的值，如果没有针对 key 的映射关系，则返回 null。（如果该实现支持 null 值，则返回 null 也可能表示此映射以前将 null 与 key 关联）。
void putAll(Map<? extends K,? extends V> m)
从指定映射中将所有映射关系复制到此映射中。

查询

Set<Map.Entry<K,V>> entrySet()
返回此映射中包含的映射关系的 Set 视图。
V get(Object key)
返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
Set keySet()
返回此映射中包含的键的 Set 视图。
Collection values()
返回此映射中包含的值的 Collection 视图。
int size()
返回此映射中的键-值映射关系数。

删除

void clear()
从此映射中移除所有映射关系。
V remove(Object key)
如果存在一个键的映射关系，则将其从此映射中移除。

判断

boolean containsKey(Object key)
如果此映射包含指定键的映射关系，则返回 true。
boolean containsValue(Object value)
如果此映射将一个或多个键映射到指定值，则返回 true。

2.1 HashMap

和HashSet集合不能保证元素的顺序一样，HashMap也不能保证key-value对的顺序。并且类似于HashSet判断两个key是否相等的标准也是: 两个key通过equals()方法比较返回true、同时两个key的hashCode值也必须相等。

2.2 HashTable

除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。现在JDK1.7 和1.8 大多都采用ConcurrentHashMap来代替，更高效，具体细节可看

https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484161&idx=1&sn=6f52fb1f714f3ffd2f96a5ee4ebab146&chksm=ebd74200dca0cb16288db11f566cb53cafc580e08fe1c570e0200058e78676f527c014ffef41#rd

Collections工具类

sort
对集合进行排序
　在使用List时想根据List中存储对象的某一字段进行排序，那么我们要用到Collections.sort方法对list排序，用Collections.sort方法对list排序有两种方法：

1 public static <T extends Comparable<? super T>> void sort(List<T> list)
2 
3 public static <T> void sort(List<T> list,
4                             Comparator<? super T> c)

第一种是list中的对象实现Comparable接口；
第二种方法是根据Collections.sort重载方法来实现。
2. shuffle
对集合进行随机排序

1 public static void shuffle(List<?> list)

2 public static void shuffle(List<?> list, Random rnd)

3.binarySearch
查找指定集合中的元素，返回所查找元素的索引

public static <T> int binarySearch(List<? extends Comparable<? super T>> list,
                                   T key)

public static <T> int binarySearch(List<? extends T> list,
                                   T key,
                                   Comparator<? super T> c)

4.reverse()
反转集合中元素的顺序

public static void reverse(List<?> list)

其他的什么Max()还有Min()方法等等我就不再赘述了

rxl2017

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
数组与集合

123
复制链接

扫一扫

专栏目录