Java编程思想学习(十二) 数组和容器
一.数组
1).数组的多种初始化方式
下面总结了初始化数组的多种方式,以及如何对指向数组的引用赋值,使其指向另一个数组对象。值得注意的是：对象数组和普通数组的各种操作基本上都是一样的；要说有什么不同的话就是对象数组默认值为null，而基本数组视本身情况而定。
1 package lkl;
2
3 import java.util.Arrays;
4
5 ///下面演示了数组的初始化
6 //包括对象数组和普通数组
7 class Base{
8 private static long counter;
9 private final long id = counter++;
10 public String toString(){
11 return "Base"+id;
12 }
13 }
14
15
16 public class ArrayOptions {
17
18 public static void main(String[] args){
19 Base[] a; ///只声明数组而不分配空间
20 Base[] b = new Base[5]; ///分配空间,默认初始化为null
21 System.out.println("b: "+Arrays.toString(b));
22
23 Base[] c=new Base[4];
24 for(int i=0;i<c.length;i++){
25 if(c[i]==null){
26 c[i]=new Base();
27 }
28 }
29
30 Base[] d={new Base(),new Base(),new Base()}; ///聚集初始化语法(隐式的使用new)
31
32 a=new Base[]{new Base(),new Base(),new Base()}; //动态聚集初始化
33
34 System.out.println("a.length= "+a.length);
35 System.out.println("b.length= "+b.length);
36 System.out.println("c.length= "+c.length);
37 System.out.println("d.lenght= "+d.length);
38 a=d;
39 System.out.println("a.lenght= "+a.length);
40
41
42 int[] e;
43 int[] f=new int[7]; ///分配空间以后会默认初始化为0
44 System.out.println(Arrays.toString(f));
45
46 int[] g=new int[4];
47 for(int i=0;i<g.length;i++){
48 g[i]=i*i;
49 }
50 int[] h={1,2,3,4};
51
52 //没有初始化就引用length，编译错误
53 //System.out.println("e.lenght= "+e.length);
54
55 System.out.println("f.length= "+f.length);
56 System.out.println("g.length= "+g.length);
57 System.out.println("h.length= "+h.length);
58
59 e=h;
60 System.out.println("e.length= "+e.length);
61 e=new int[]{3,4,3};
62 System.out.println("e.length= "+e.length);
63 }/*Output
64 b: [null, null, null, null, null]
65 a.length= 3
66 b.length= 5
67 c.length= 4
68 d.lenght= 3
69 a.lenght= 3
70 [0, 0, 0, 0, 0, 0, 0]
71 f.length= 7
72 g.length= 4
73 h.length= 4
74 e.length= 4
75 e.length= 3
76 */
77 }2). 从函数中返回一个数组
对于这种情况，如果在C/C++中我们可能会选择返回一个指针，因为不可能直接返回一个数组。但是在java里允许我们直接返回一个数组(当然实际上来讲还是一个引用)；并且使用完了后我们也不需要手动的销毁数组，垃圾回收器会帮助我们进行清理。所以返回一个数组和返回一个普通值就没什么两样了。
1 package lkl;
2
3 import java.util.*;
4
5 ///返回一个数组
6 ///函数可以显示的声明返回一个数组
7 ///这与返回其它类型并没有什么不同，实际上都是返回一个引用
8 //我们也不需要去手动的释放这个数组的内存，在适当的时候垃圾回收器会情理掉它的
9 public class ReturnArray {
10
11 private Random rand = new Random();
12 public int[] fun(int n){ ///返回一个具有大小为n的int类型数组
13 int[] a=new int[n];
14 for(int i=0;i<n;i++)
15 a[i]=rand.nextInt(1000);
16 return a;
17 }
18
19 public static void main(String[] args){
20
21 ReturnArray ret = new ReturnArray();
22 for(int i=1;i<=10;i++){
23 System.out.println(Arrays.toString(ret.fun(i)));
24 }
25 }/*
26 [627]
27 [181, 296]
28 [337, 415, 233]
29 [617, 607, 956, 897]
30 [985, 847, 965, 620, 302]
31 [955, 727, 320, 328, 741, 631]
32 [298, 532, 478, 116, 448, 718, 754]
33 [722, 531, 491, 183, 560, 410, 657, 20]
34 [95, 9, 491, 277, 431, 401, 556, 101, 871]
35 [600, 311, 221, 761, 9, 689, 664, 40, 167, 636]
36 */
37 }3).多维数组
java中的多维数组和C++中是类似的。
1 package lkl;
2
3 import java.util.Arrays;
4 import java.util.*;
5
6 ///多维数组的创建和初始化
7 public class Multi {
8
9 public static void main(String[] args){
10 int[][] a={{1,2,3},{4,5,6}};///花括号可以分隔每维
11
12 int[][] b=new int[2][4]; ///默认初始化为0
13 Base[][] c = new Base[2][4]; ///对于对象数组也没有什么不同
14
15 ///deepToString()方法可以将多维数组转换成多个String
16 System.out.println(Arrays.deepToString(a));
17
18 System.out.println(Arrays.deepToString(b));
19 System.out.println(Arrays.deepToString(c));
20
21
22 ///数组中构成矩阵的每个向量都可以具有任意的长度
23 Random rand = new Random(56);
24
25 int[][][] d=new int[rand.nextInt(8)][][];
26 for(int i=0;i<d.length;i++){
27 d[i]=new int[rand.nextInt(5)][];
28 for(int j=0;j<d[i].length;j++){
29 d[i][j]=new int[rand.nextInt(4)];
30 }
31 }
32 System.out.println(Arrays.deepToString(d));
33 }
34 /*Output
35 [[1, 2, 3], [4, 5, 6]]
36 [[0, 0, 0, 0], [0, 0, 0, 0]]
37 [[null, null, null, null], [null, null, null, null]]
38 [[[0], [0, 0, 0], [0]], [[0], []], [[], [0]], [], [[0, 0], [0, 0, 0], [0, 0], [0, 0]]]
39 */
40 }4).数组的填充函数Arrays.fill()
我们可以调用这个函数使用指定的值对数组进行填充，但是这种填充和C++中的memset()不一样，它不是整块的内存复制，实际上仍是使用for循环进行赋值。这就导致我们可以指定任意的填充值，但是相应的其效率就不是那么令人满意了。这个函数适用与各种数组，并且还有一个重载版本可以让我们指定填充的起点和终点。
1 package lkl;
2
3 import java.util.Arrays;
4
5 public class Functiion {
6
7 public static void main(String[] args){
8
9 //fill()函数可以允许我们用一个固定的值来进行填充
10 ///它的另一种重载形式可以运行我们指定填充的起点和终点
11 int[] a=new int[10];
12 Arrays.fill(a, 1);
13 System.out.println(Arrays.toString(a));
14 Arrays.fill(a, 0, 4, 2); ///这种格式调用时注意起点包括但终点不包括
15 Arrays.fill(a, 4,10,4);
16 System.out.println(Arrays.toString(a));
17 }/*Output
18 [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
19 [2, 2, 2, 2, 4, 4, 4, 4, 4, 4]
20 */
21 }5).数组的整体复制和比较
数组的整体复制使用的不是Arrays包下的函数而是System包下的arraycopy()函数。arraycopy()函数所需要的参数有：源数组，表示从源数组复制的起始位置，目的数组，表示目的数组开始赋值的起始位置，需要复制元素的个数。因为这个函数底层使用的整块内存的一个复制，所以效率上要比for循环好很多。
另外，对于对象数组我们复制的只是对象的引用，而不是对象本身的拷贝。并且这个函数也不会自动的执行自动包装和拆包，所以两个数组必须要有相同的类型。
1 package lkl;
2
3 import java.util.Arrays;
4
5 //System类提供了一个arraycopy()函数用来进行数组的复制
6 //这种复制比for循环快的多
7 //arraycopy须要的参数有：源数组，表示从源数组开始复制的位置，
8 ///目的数组，复制到目的数组的位置，以及复制元素的个数
9 ///另外arraycopy()不会自动包装和自动拆包，在复制对象数组时复制的只有
10 //引用，而不是对对象进行拷贝
11 public class ArrayCopy {
12
13 public static void main(String[] args){
14
15 int[] a=new int[4];
16 int[] b=new int[6];
17 Arrays.fill(a, 10);
18 Arrays.fill(b, 20);
19 System.out.println("b= "+Arrays.toString(b));
20 System.arraycopy(a, 0, b, 2, 3);
21 System.out.println("b= "+Arrays.toString(b));
22
23 Integer[] c=new Integer[10];
24 Integer[] d=new Integer[6];
25 Arrays.fill(c, new Integer(3));
26 Arrays.fill(d, new Integer(5));
27 System.out.println("c= "+Arrays.toString(c));
28 System.arraycopy(d, 1, c, 2, 3);
29 System.out.println("c= "+Arrays.toString(c));
30 }/*Output
31 b= [20, 20, 20, 20, 20, 20]
32 b= [20, 20, 10, 10, 10, 20]
33 c= [3, 3, 3, 3, 3, 3, 3, 3, 3, 3]
34 c= [3, 3, 5, 5, 5, 3, 3, 3, 3, 3]
35 */
36 }Arrays包下提供了equals()方法用于整个数组的比较。两个数组相等的标准是：具有相同的尺寸，并且对应位上的元素相等(通过对每一个元素使用equals()作比较来进行判断)。如果数组中装的是我们自己定义的对象引用，那么要确保重写了equals()方法，否则比较就会出错。
1 package lkl;
2
3 import java.util.Arrays;
4
5 //用于判断数组是否相等的方法
6 ///Arrays.equals()
7 //两个数组相等的定义为数组的尺寸相同并且对应位元素相同
8
9 class MyClass{
10 private int i;
11 public MyClass(int i){
12 this.i=i;
13 }
14 @Override//重写equals()函数
15 public boolean equals(Object t){
16 if(t==null) return false;
17 if(t.getClass()!=MyClass.class)
18 return false;
19 return ((MyClass)t).i==this.i;
20 }
21 }
22
23 public class ArrayEquals {
24
25 public static void main(String[] args){
26
27 int[] a1=new int[10];
28 int[] a2=new int[10];
29 Arrays.fill(a1, 11);
30 Arrays.fill(a2, 11);
31 System.out.println(Arrays.equals(a1, a2));
32 a1[2]=10;
33 System.out.println(Arrays.equals(a1, a2));
34
35 //如果是我们自己定义类型的数组就有可能出问题了
36 ///必须要自己重写equals()函数，提供相等的标准
37 MyClass[] m1=new MyClass[4];
38 MyClass[] m2=new MyClass[4];
39 Arrays.fill(m2, new MyClass(3));
40 Arrays.fill(m1, new MyClass(3));
41 System.out.println("m1==m2? "+Arrays.equals(m1,m2));
42 }/*
43 true
44 false
45 m1==m2? true
46 */
47 }6).自定义元素的比较规则
有时候我们需要自己定义数组元素的比较规则，以便进行排序和查找等操作。java提供了两种方法来提供比较的功能。一种是实现java.lang.Comparable接口，使你的类具有天生的比较能力，此接口很简单，只有compareTo()一个方法。此方法接收另一个Object为参数，如果当前对象小于参数则返回负值，相等返回0，大于返回正值。下面的类实现了Comparable接口，我们用排序函数进行检验。
1 package lkl;
2 import java.lang.*;
3 import java.util.*;
4 //有时候我们需要自定义如何比较对象
5 //为此有两种方法可以实现，第一种就是实现java.lang.Comparable接口
6 //另一种方法就是实习Comparator接口
7
8 public class CompType implements Comparable<CompType>{
9 int i;
10 int j;
11
12 public CompType(int n1,int n2){
13 i=n1; j=n2;
14 }
15
16 public String toString(){
17 return "[ i= "+i+" j= "+j+"]";
18 }
19
20 //先按i的大小排序，i相等就按j大小排序
21 ///实现Comparable接口就必须实现CompareTo()方法
22 ///compareTo()的返回值只有三种，-1,0,1，分别表示小于，等于，大于
23 public int compareTo(CompType T){
24 if(i==T.i){
25 return (j<T.j?-1:(j==T.j?0:1));
26 }
27 return (i<T.i?-1:(i==T.i?0:1));
28 }
29
30 public static void main(String[] args){
31 Random rand = new Random(45);
32 CompType[] ct=new CompType[4];
33 for(int i=0;i<4;i++)
34 ct[i]=new CompType(rand.nextInt(10),rand.nextInt(12));
35
36 System.out.println("排序之前： ");
37 for(int i=0;i<4;i++){
38 System.out.println(ct[i]);
39 }
40 Arrays.sort(ct);
41
42 System.out.println("\n排序之后：");
43 for(int i=0;i<4;i++){
44 System.out.println(ct[i]);
45 }
46 }/*
47 排序之前：
48 [ i= 9 j= 3]
49 [ i= 1 j= 8]
50 [ i= 7 j= 3]
51 [ i= 1 j= 3]
52
53 排序之后：
54 [ i= 1 j= 3]
55 [ i= 1 j= 8]
56 [ i= 7 j= 3]
57 [ i= 9 j= 3]
58 */
59 }第二种方法就就是创建一个实现了Comparator接口的类，将其一个对象作为比较标准传入排序函数中。这个类有compare()，equals()两个方法。因为每个类都会继承Object类的equals()方法，所以一般情况下我们只需要实现compare()作为比较标准就行了。
1 package lkl;
2
3 import java.util.*;
4
5 ///自己实现Comparator接口，定义排序标准,实现compare()函数
6 ///排序时传入一个Comparator对象
7 ///下面的定义表示的是处理CompType类型的比较
8 class MyComparator implements Comparator<CompType>{
9 public int compare(CompType t1,CompType t2){
10 if(t1.i==t2.i){
11 return (t1.j<t2.j?-1:(t1.j==t2.j?0:1));
12 }
13 return (t1.i<t2.i?-1:(t1.j==t2.j?0:1));
14 }
15 }
16
17 public class ComapratorTest {
18
19 public static void main(String[] args){
20 Random rand = new Random(45);
21 CompType[] ct=new CompType[4];
22 for(int i=0;i<4;i++)
23 ct[i]=new CompType(rand.nextInt(10),rand.nextInt(12));
24 System.out.println("排序之前： ");
25 for(int i=0;i<4;i++){
26 System.out.println(ct[i]);
27 }
28 Arrays.sort(ct,new MyComparator());
29 System.out.println("\n排序之后：");
30 for(int i=0;i<4;i++){
31 System.out.println(ct[i]);
32 }
33 }
34 }7).数组的排序和查找
使用内置的排序方法，可以对任意的基本类型数组进行排序，也可以对任意的对象数组进行排序。只要该对象实现了Comparable接口或则是具有相关联的Comparator。对于查找，只要数组已经排好序，我们就可以使用Arrays.binarySearch()执行快速的二分查找。如果查找到了该元素，返回其位置。如果返回的是一个负值，说明数组中不包含此元素，这个负值还表示该元素应该插入的位置。值得注意的是，如果使用Comparator排序了某个对象数组(基本数组是不能用Comparator进行排序的)，那么在对其进行二分时也要传入一个相同的Comparator对象(使用一个重载函数版本)。
1 package lkl;
2 import java.util.*;
3
4 ///数组的排序与查找问题
5 ///java中内置了排序算法，可以对各种类型的数组进行排序
6 ///只要该对象实现了Comparable接口或具有相关联的Comparator
7 ///java标准类库中的排序算法对正排序的特殊类型进行了优化---针对基本类型设计的
8 //“快速排序”以及针对对象设计的稳定归并排序
9
10 ///对排序以后的数组我们可以直接使用内置的二分查找
11 //如果使用了Comparator排序了某个对象数组（基本类型数组无法使用Comparator进行排序）
12 //在使用binarySearch()时也需要提供同样的
13 public class ArraySort {
14
15 public static void main(String[] args){
16 Random rand= new Random(330);
17 int[] a=new int[10];
18 for(int i=0;i<10;i++)
19 a[i]=rand.nextInt(20);
20 int t=a[4];
21 System.out.println("排序前： ");
22 System.out.println(Arrays.toString(a));
23 Arrays.sort(a);
24 System.out.println("排序后：");
25 System.out.println(Arrays.toString(a));
26
27 System.out.println("二分查找"+t+"的位置为为："+Arrays.binarySearch(a, t));
28
29
30 ///下面是对前面对象数组二分的演示
31 CompType[] ct=new CompType[4];
32 for(int i=0;i<4;i++)
33 ct[i]=new CompType(rand.nextInt(10),rand.nextInt(12));
34 CompType T =ct[2];
35 System.out.println("T= "+T);
36 Arrays.sort(ct,new MyComparator());
37 System.out.println("排序之后");
38 for(int i=0;i<4;i++){
39 System.out.println(ct[i]);
40 }
41 System.out.println("T的位置为"+Arrays.binarySearch(ct, T,new MyComparator()));
42 }
43 }二.容器
list(interface) 次序是list最重要的特点；它保证维护元素特定的顺序。list为collection添加了许多开发方法 ，使得能够向list中间插入与移除元素。（这只推荐linkedlist使用。）一个list可以生成listiterator，使用它可以从两个方向遍历list，也可以从list中间插入和移除元素。
arraylist* 由数组实现的list。允许对元素进行快速随机访问，但是向list中间插入与移除元素的速度很慢。listiterator只应该用来由后向前遍历arraylist，而不是用来插入和移除元素，因为那比linkedlist开销要大很多。
linkedlist 对顺序访问进行了优化，向list中间插入与删除的开销并不大。随机访问则相对较慢。（使用arraylist代替。）还具有下列开发方法 ：addfirst()，addlast()，getfirst()，getlast()，removefirst()，和removelast()，这些开发方法 （没有在任何接口或基类中定义过）使得linkedlist可以当作堆栈、队列和双向队列使用。
stack “栈”通常是指“后进先出”(lifo)的容器。linkedlist具有能够直接实现栈的所有功能的开发方法 ，因此可以直接将linkedlist作为栈使用。不推荐使用java.util包下的stack，推荐使用linkedlist实现自己的stack。
public class stack<t> {
private linkedlist<t> storage = new linkedlist<t>();
public void push(t v) { storage.addfirst(v); }
public t peek() { return storage.getfirst(); }
public t pop() { return storage.removefirst(); }
public boolean empty() { return storage.isempty(); }
public string tostring() { return storage.tostring(); }
}
queue(interface) 队列是一个典型的先进先出(fifo)的容器。
linkedlist linkedlist提供了开发方法 以支持队列的行为，并且它实现了queue接口，因此linkedlist可以用作queue的一种实现。queue<t> queue = new linkedlist<t>();
queue接口窄化了对linkedllst的开发方法 的访问权限，以使得只
有恰当的开发方法 才可以使用，因此，你能够访问的linkedlist的开发方法 会变少（这里你实际上可以将queue转型回llnkedlist，但是至少我们不鼓励这么做）。
priorityqueue(java se5) 优先级队列. 当你在priorityqueue上调用offer()开发方法 来插入一个对象时，这个对象会在队列中被排序。默认的排序将使用对象在队列中的自然顺序，但是你可以通过提供自己的comparator来修改这个顺序。priorityqueue可以确保当你调用peek()．poll()和remove()开发方法 时，获取的元素将是队列中优先级最高的元素。
set(interface) 存入set的每个元素都必须是唯一的，因为set不保存重复元素。加入set的元素必须定义equals()开发方法 以确保对象的唯—性。set与collection有完全一样的接口。set接口不保证维护元素的次序
hashset* 为快速查找而设计的set。存入hashset的必须定义hashcode()
treeset 保持次序的set．底层为树结构。使用它可以从set中提取有序的序列。
元素必须实现comparable接口
linkedhashset 具有hashset的查询速度，且内部使用链表维护元素的顺序（插入的次序）。于是在使用迭代器遍历set时，结果会按元素插入的次序显示。元素也必须定义hashcode()开发方法
map(interface) 一组成对的“键值对”对象，允许你使用键来查找值。
hashmap* map基于数列表的实现（它取代了hasbtable）。插入和查询“键值对”的开销是固定的。可以通过构造器设置容量和负载因子，以调整容器的性能
llnkedhashmap 类似于hashmap．但是迭代遍历它时，取得“键值对”的顺序是其插入次序，或者是最近最少使用(lru)的次序。只比hashmap慢一点．而在迭代访问时反而更快，因为它使用链表维护内部次序
treemap 基于红黑树的实现。查看“键”或“键值对”时，它们会被排序（次序由comparable或comparator决定）．treemap的特点在于，所得到的结果是经过排序的。treemap是唯一的带有submap()开发方法 的map．它可以返回一个子树
weakhashmap 弱键(wcak key)映射，允许释放映射所指向的对象。这是为解决某类特殊问题而设计的。如果映射之外没有引用指向某个“键”，则此。键一可以被垃圾收集器回收
concurrenthashmap 一种线程安全的map，它不涉及同步加锁。
ldentityhashmap 使用==代替equals()对“键”进行比较的散列映射。
转载：http://blog.csdn.net/acm_lkl/article/details/46753265
转载于:https://www.cnblogs.com/benchao/p/5268307.html
Java编程思想学习(十二) 数组和容器相关推荐
- Java编程思想—第十二十三章
1.在堆中new出异常对象 2.通常用System.err来输出异常,而System.out可能会被重定向,不建议用. 3.在catch中抛出异常throw e.则之后的catch子句将被忽略. 4. ...
- Java编程思想学习笔记-第11章
<?xml version="1.0" encoding="utf-8"?> Java编程思想学习笔记-第11章 Java编程思想学习笔记-第11章 ...
- JAVA编程思想学习笔记——第一章 对象导论
搞了一年多java,野路子出身,发现java基础这块还是相当的薄弱!故决定学习<Java编程思想>这本书.在此把学习的知识点记录下! 面向对象的五大特性 1.万物皆为对象 2.程序是对象的 ...
- java编程思想学习（1）:抽象
今天开始java编程思想的导读,希望自己能更好的理解程序.全书1461页,恐怖,尽量一天看十页八. OOP 面向对象程序设计 记录一点东西八 第一个小课程,抽象过程 看看概念 1万物皆为对象 2程序是 ...
- Java编程思想学习笔记4 - 序列化技术
今天来学习下Java序列化和反序列化技术,笔者对<Java编程思想>中的内容,结合网上各位前辈的帖子进行了整理和补充,包括: 序列化概述 Java原生序列化技术 Hessian序列化技术 ...
- Java编程思想学习(一)----对象导论中多态的理解
1.1抽象过程 1)万物皆对象. 2)程序是对象的集合,他们通过发送消息来告知彼此所要求做的. 3)每个对象都有自己的由其他对象所构成的存储. 4)每个对象都拥有其类型. 5)某一特定类型的所有对象都 ...
- JAVA编程思想学习手账初整理
redis: 缓存击穿:对于访问过期的key查询数据时,加锁,保证只有一个线程去底层获取数据,并返回结果缓存 缓存穿透:对于访问不存在的key时给出空结果并缓存,或引入布隆过滤器将数据提前缓存在布隆过 ...
- Java编程思想 学习笔记1
一.对象导论 1.抽象过程 Alan Kay曾经总结了第一个成功的面向对象语言.同时也是Java所基于的语言之一的Smalltalk的五个基本特性,这些特性表现了纯粹的面向对象程序设计方式 1)万物皆 ...
- Java编程思想学习-《第二章 一切都是对象》
第2章 一切都是对象 尽管Java是基于C++的,但是相比之下,Java是一种更"纯粹"的面向对象程序设计语言.Java语言假设我们只进行面向对象的程序设计.也就是说,在开始用Ja ...
最新文章
- 一种ui app写法
- golang 代码实现 修改配置文件
- 自律到极致-人生才精致：第4期
- SPringMVC使用总结
- 移动设备的配置测试（译）
- long java 比较_Java到底是不是一种纯面向对象语言？
- Zuul：Cookie和动态路由
- python字典的应用实验报告_Python字典应用的一个例子
- 通过GPUImage实现40+种滤镜与实时美颜功能
- asp在线html编辑器,ASP下使用FCKeditor在线编辑器的方法
- 字节跳动斥巨资开发出《Python知识手册》
- 精密电阻阻值表丝印大全
- GRE常见的熟词生义
- matlab 白色变红色
- 更干净的PC电源，还能净化空气，艾湃电竞AP-550Ti电源上手
- 港联证券|基金和股票的区别是什么？谁更适合做短线？
- 命令模式——经营烧烤摊
- 人生第一次面试还是霸面----cvte
- AIX7.1 安装配置 HPE 3PAR 存储驱动软件
- 降压电荷泵原理详细介绍