java编程思想--16数组

数组
数组与其他种类的容器之间的区别有三方面：效率、类型和保存基本类型的能力。在java中，数组是一种效率最高的存储和随机访问对象引用序列的方式。数组就是一个简单的线性序列，这使得元素访问非常快速，但也损失了其他一些特性。当创建了一个数组对象（将数组本身作为对象看待），数组的大小就被固定了，并且这个数组的生命周期也是不可改变的。通常用移到新数组中。这正式ArrayList类的行为方式。然而这种弹性带来的开销，使得ArrayList比数组效率低得多。
在C++中，容器类vector的确知道自己保存的对象是何类型。不过与java中的数组相比，它有一个缺点：C++中vector的操作符[]不做边界检查，所以可能会越界操作(然而，要问vector有多大是可能的，at()方法的确会执行边界检查)。而在java中，无论使用数组或容器，都有边界检查。如果越界操作就会得到一个RuntimeException异常。这类异常通常说明是程序员的错误，因此你不必自己做越界检查。多说一句，为了速度，C++的vector不会对每次存取做边界检查；而java的数组与容器会因为时刻存在的边界检查带来固定的性能开销。
其他通用的容器类：List、Set和Map，它们不以具体的类型来处理对象。也就是说
，它们将所有对象都按Object类型处理，即java中所有类的基类。从某个角度来说，这种方式很好：你只需要构建一个容器，任意的java对象都可以放入其中。（除开基本类型之外，数组可以放入容器作为使用Java基本包装器类的常量，或者作为包装在你自己的类中的可变值。）这正是数组比通用容器优越的第二点：当你创建一个数组时，它只能保存特定类型（这与第三点相关——数组可以保存基本类型，容器则不能）。这意味着会在编译时做类型检查。以防错误的类型插入数组，或取出数据时弄错类型。当然无论在编译时还是运行时，Java都会阻止你向对象发送不恰当的消息。所以，并不是说哪种方法更不安全，只是如果编译时就能够指出错误，那么程序可以运行得更快，也减少了程序的使用者被异常吓着的可能性。

    数组，书中没有再去细细的分析，而且建议优先使用容器，因为从效率、类型、保存基本类型上看，可能只有在效率上还有些优势，但是在稍微灵活些的实现上，似乎都会有很多限制；个人觉得从其方便性和理解上（从c过来的人）可能更简单直观；数组的赋值，特别是赋以根据自己特定需要的有意义的值，不是那么直接，（也包括容器），需要用Generator类（根据自己的需要而修改产生的）解决（书上给了很好的示例）。最后就是介绍了System.arraycopy()、binarySearch()、Array.asList、CompareTo等实用方法。
    深入容器：可以理解为更好的使用容器，推荐一般默认常用的容器。ArrayList、HashSet、HashMap

    首先比较完整的容器图很好，可以看到我们最常用的List、Set、Queue是继承自Collection，而Map是单独出来的接口，带有Abstract开头的抽象类，方便我们自定义需要的容器，其实最常用的还是原来那张简化图足够了。先说说共性的，常考虑的
   （1）容器填充：fill() addALL() 或者自定义的Generator
   （2）Collection常用方法：书中有张表很详细。注意的是不包括随机访问元素的get()方法（Set是自己维护内部顺序）；如clear() contains() remove() iterator()
   （3）UnsupportedOperationException异常：“执行各种不同的添加和移除的方法在Collection接口中都是可选操作”，是特殊的接口定义方法，不保证调用某些方法是有意义的行为，当出现这种没有实际定义的方法是产生异常；这样的好处是防止出现接口爆炸的情况。
   （4）散列（HashCode方法）：可以根据需要自己覆盖原有的该方法，也可以利用Object自带的hashcode方法；应该都学过散列的冲突问题，因此可以想到散列值对应的位置存储的该是一个存放引用的列表；相应的就会理解在HashMap中为什么要弄个容量和负载因子的设置了，如果能够估计HashMap的使用量，合理的预先设置会减少再散列以及查找元素带来的性能损耗问题。
   （5）同步控制：容器在①防止多个进程同时修改同一个容器②获取迭代之后（iterator），遍历完之前，的插入、删除等操作都有报错。
   （6）持有引用：主要说了为垃圾回收提供了不同级别的间接提示的Java.lang.ref类库：
    SoftReference（对内存敏感的高速缓存）、WeakReference（“规范映射”，同一个值只有一个存储空间）、PhantomReference（最弱，依赖于ReferenceQueue）；
    具体的List、Set、Map的使用，下面的表更有用。

Stack
栈（Stack）是限制仅在表的一端进行插入和删除运算的线性表。
java 没有栈这样的数据结构，如果想利用先进后出（FILO）这样的数据结构，就必须自己实现。

要实现Stack，至少应该包括：
1. pop() 出栈操作，弹出栈顶元素。
2. push(E e) 入栈操作
3. peek() 查看栈顶元素
4. isEmpty() 栈为空

另外，实现一个栈，还应该考虑到几个问题：
1. 栈的初始大小以及栈满以后如何新增栈空间
2. 对栈进行更新时需要进行同步

有三种实现的方式，数组，容器，以及链表的方法。

数据：

package gsm;
import java.util.*;

public class StackArray{
private int[] array;//用数组实现
private int top; //栈顶指针
private final static int size = 100;
public StackArray(){
array = new int[size];
top = -1; //栈空的时候
}
//压栈
public void push(int element){
if(top == size-1){
throw new StackOverflowError();
}
else
array[++top] = element;
}
//弹栈
public int pop(){
if(top == -1){
throw new EmptyStackException();
}
return array[top--];
}
//判断是否为空
public boolean isEmpty(){
return top == -1;
}
//返回栈顶元素
public Integer peek(){
if(top == -1){
throw new EmptyStackException();
}
return array[top];
}
}
容器

package gsm;

public interface Stack {
public T pop();
public void push(T element);
public boolean isEmpty();
public T peek();
}

package gsm;
import java.util.*;

public class StackList implements Stack {
private List list ; //用容器实现
StackList(){
list = new ArrayList();
}
//弹栈
public T pop(){
if(this.isEmpty() == true){
throw new EmptyStackException();
}

return list.remove(list.size()-1);
}
//压栈
public void push(T element){
list.add(element);
}
//判断是否为空
public boolean isEmpty(){
return list.size() == 0;
}
//返回栈顶元素
public T peek(){
if(this.isEmpty() == true){
throw new EmptyStackException();
}
return list.get(list.size()-1);
}
}
链表

package gsm;

import java.util.EmptyStackException;

public class LinkedStack implements Stack{
//不用容器或者数组等数据结构存储节点
//Node定义一个节点类
private static class Node{
private U item; //存储的data
private Node next; //类似指针
Node(){
this.item = null;
this.next = null;
}
Node(U item, Node next){
this.item = item;
this.next = next;
}
boolean end(){
return item == null && next == null;
}
}

private Node top ; //栈顶指针
LinkedStack(){
top = new Node();


、Arrays类：提供了操作数组的一些static方法，如
fill() 用于以某个值填充整个数组。
sort() 用于对数组的排序，需要参数的类型实现Comparable接口
binarySearch() 用于在已经排序的数组中查找元素。
asList() 接受任意的数组为参数，并将其转变为List容器。
……
2、如果一个字符串需要多次改变其值，那么应该使用更高效的StringBuffer取代String。
3、复制数组System.arraycopy()，用它复制数组比用for循环复制要快得多。
4、基本类型数组和对象数组都可以复制，然而，如果复制对象数组，那么只是复制了对象的引用——而不是对象本身的拷贝。这被称作“浅复制”。
5、数组的比较：
Arrays .equal()
import java.util.Arrays;
public class Test{
public static void main(String[] args){
String[] s1 = new String[5];
Arrays.fill(s1,"Hi");
String[] s2 = {"Hi", "Hi", "Hi", "Hi", "Hi"};
System.out.println(Arrays.equals(s1, s2));
System.out.println(s1.equals(s2));
System.out.println(s1==s2);
}
}
1).对于Arrays.equals ，S1的所以元素指向同一个对象，而数组s2包含五个相互独立的对象，然而，数组相等是基于内容的（通过Object.equal()比较），所以结果为true。
2).但是后两个语句输入都是false。原因呢？
6、数组元素的比较：
1).Java有两种方式来提供比较功能。第一种是实现java.lang.Comparable接口，此接口中只有compareTo(Object o)一个方法。
2).实现Comparator接口，区中有俩个方法compare(Object o1, Object o2)和equals(Object o)两个方法。
7、Java标准库：针对基本类型设计的“快速排序(Quicksort)”，针对对象设计的“稳定归并排序”。
8、若找到目标，Arrays.binarySearch()产生的返回值等于或大于。否则，它将产生负返回值，表示若要保持数组的排序状态，此目标元素所应该插入的位置，这个负值得计算方式是：
-（插入点）- 1；
         插入点是指，第一个大于查找对象的元素在数组的位置。如果数组中所有元素都小于要查找的对象吗，“插入点”就等于被查找数组的大小size()。
         如果数组中包含重复的元素，则无法保证找到的是哪一个。此算法确实不是专为包含重复元素的数组而设计的，不过任然可用。
         如果需要对没有重复元素的数组排序，可以使用TreeSet（保持数组顺序），或者LinkedHashSet（保持插入顺序.。
9、基本数据数组无法使用Comparator进行排序。
10、在使用binarySearch()时必须提供同样地Comparator（使用方法的重载版本）。
11、数组是效率最高的保持一组对象的方式，它是你的第一选择。而且，如果要保存基本类型，则只能用数组。
12、 Java容器类类库的用途是"保存对象",并将其划分为两个不同的概念：
1).Collection。一个独立的元素，这些元素都服从一条或多条规则。List必须保存元素特定的顺序，而Set不能有重复元素。
2).Map。一组成对的”键值对“对象。初看起来这似乎应该是一个Collection，其元素是成对的对象，但是这样的设计实现起来太笨拙了，于是我们将Map明确提取出来形成一个独立的概念。另一方面，如果使用Collection表示Map的部分内容，会便于查看此部分内容。因此Map可以返回所有键组成的Set，所有值组成的Collection，或其键值对组成的Set；并且象数组一样容易扩展成多维Map，无需增加新的概念，只要让Map中键值对的每个“值”也是一个Map即可（此Map中的“值”还可以是Map，依此类推）。
13、
1).List按对象进入的顺序保存对象，不做排序或编辑操作。
2).Set对每个对象只接受一次，并使用自己内部的排序方法（通常，你只关心某个元素是否属于Set,而不关心它的顺序--否则应该使用List）。
3).Map同样对每个元素保存一份，但这是基于"键"的，Map也有内置的排序，因而不关心元素添加的顺序。
4).如果添加元素的顺序对你很重要，应该使用 LinkedHashSet或者LinkedHashMap.、
14、Collections中的fill()方法也是只复制同一个对象的引用来填充整个容器，并且只对List对象有用。
15、容器的缺点：将对象加入容器的时候就丢失了类型信息。容器只保存对Object的引用，Object是所有类的基类，因此容器可以保存任何类型的对象。（当然不包括基本类型，因为它们不是真正的对象，没有继承任何东西。）
16、如果原本是使用ArrayList，但是后来考虑到容器的特点，该用Set，那该怎么做？或者你打算写通用的代码，它们只是使用容器，不知道或者说不关心容器的类型，那么如何才能不重写代码就可以应用与不同类型的容器？
         迭代器(也是一种设计模式)的概念可以用于达成次目的。迭代器是一个对象，它的工作是遍历并选择序列中的对象，而客户端程序员不必知道或关心该序列底层的结构(也就是不同容器的类型)。此外，迭代器通常被称为"轻量级"对象：创建它的代价小。
17、Collection中并不包括随机访问所选择元素的get()方法。因为Collection包括Set，而Set是自己维护内部顺序的（这使得随机访问变得没意义）。因此，如果你想要检查Collection中的元素，必须使用迭代器。
18、Java中，Vector、Stack和Hashtable已经过时。
19、List的功能方法

         如果再开发环境中，性能开销主要由其他因素产生，那么ArrayList与LinkedList之间的开销差异就不重要了，无论使用哪一种都可以。
20、Set的功能方法：
         Set具有与Collection完全一样得接口，因此没有任何额外的功能。实际上Set就是Collection，只是行为不同。（这是继承与多态思想的典型应用：表现不同的行为。）Set不保存重复的元素。

import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

public class TestSet{
static void fill(Set