北京圣思园_Java SE Lesson 5

Java SE Lesson 5
 

2.  在Java中声明final常量时通常都会加上static关键字，这样对象的每个实例

都会访问唯一一份常量值。就不用在每一个对象中生成一个常量。

 

4.  集合中存放的依然是对象的引用而不是对象本身。

 

区别： int [] a =new int[4] ;

              类： Array  : 无构造方法，所有方法都是静态的

              类： ArrayList : 有构造方法， 所有方法都是非静态的。

 

java.util

Class ArrayList<E>

ArrayList：我们可以将其看作是能够自动增长容量的数组。

 

5.  ArrayList底层采用数组实现，当使用不带参数的构造方法生成ArrayList对象

时，实际上会在底层生成一个长度为10的Object类型数组

 

6.  如果增加的元素个数超过了10个，那么ArrayList底层会新生成一个数组，长度为原数组的1.5倍+1，然后将原数组的内容复制到新数组当中，并且后续增加的内容都会放到新数组当中。当新数组无法容纳增加的元素时，重复该过程。

 

8.  集合当中只能放置对象的引用，无法放置原生数据类型，我们需要使用原生数据类型的包装类才能加入到集合当中。

 

9.  集合当中放置的都是Object类型，因此取出来的也是Object类型，那么必须要使用强制类型转换将其转换为真正的类型（放置进去的类型）。

 

java.util

Class LinkedList<E>

单向链表:

 

public class Node

{

       Stringdata; // 存放节点数据本身

      

       Nodenext; // 存放指向下一个节点的引用

      

       publicNode(String data)

       {

              this.data= data;

       }

}

 

双向循环链表:

 

public class Node2

{

       Node2previous;

 

       Stringdata;

 

       Node2next;

      

       publicNode2(String data)

       {

              this.data= data;

       }

}

 

建立链表间的关系:

public class Node2Test

{    

       publicstatic void main(String[] args)

       {

              Node2 node1 = new Node2("node1");

              Node2 node2 = new Node2("node2");

              Node2 node3 = new Node2("node3");

             

              node1.next= node2;

              node2.previous= node1;

             

              node2.next= node3;

              node3.previous= node2;

             

              node3.next= node1;

              node1.previous= node3;

 

 

       }

}

 

LinkedList 的底层就是一个双向链表.

 

10. 关于ArrayList与LinkedList的比较分析

a) ArrayList底层采用数组实现，LinkedList底层采用双向链表实现。

b)  当执行插入或者删除操作时，采用LinkedList比较好。

c)  当执行搜索操作时，采用ArrayList比较好。

 

LinkedList 中的remove()    add()    get() 方法源代码分析:

 

private E
remove(Entry<E>e) {
   if (e ==
header)
       throw
newNoSuchElementException();
 
        E result = e.element;
   e.previous.next = e.next;
   e.next.previous = e.previous;
        e.next = e.previous =
null;
        e.element = null;
   size--;
   modCount++;
        return result;
}

 

 

private Entry<E>
addBefore(E e, Entry<E> entry) {
   Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
   newEntry.previous.next = newEntry;
   newEntry.next.previous = newEntry;
   size++;
   modCount++;
   return newEntry;
    }

 

public E get(int index) {
        return
entry(index).element;
}

 

 

private Entry<E>
entry(int index) {
        if (index < 0 || index >=
size)
            throw
new IndexOutOfBoundsException("Index: "+index+
                                               ", Size: "+size);
        Entry<E> e = header;
        if (index < (size >> 1)) {
            for (int i = 0; i <= index; i++)
                e = e.next;
        } else {
            for (int i =
size; i > index; i--)
                e = e.previous;
        }
        return e;
    }
 

Java SE Lesson 6
 

java.util
Interface Queue<E>

java.util
Class Stack<E>

自己写一个类用来实现栈和队列

Queue :  put (Object  o) get()  isEmpty()  

Stack  :  push(Object  o) pop()  peek()  isEmpty()

无论是栈还是队列， 里面都会维护一个成员变量，该成员变量用于维护存储栈或队列的元素。该成员变量请使用LinkedList类型。

 

1.  当向ArrayList添加一个对象的引用时，实际上就是将该对象放置到了ArrayList底层所维护的数组当中；当向LinkedList中添加一个对象时，实际上LinkedList内部会生成一个Entry对象，该Entry对象的结构为：


Entry

{

  Entry previous;

  Object element;

  Entry next;

}

其中的Object类型的元素element就是我们向LinkedList 中所添加的元素，然后Entry又构造好了向前与向后的引用previous、next，最后将生成的这个Entry对象加入到了链表当中。换句话说，LinkedList中所维护的是一个个的Entry对象。

 

2.  关于Object类的equals方法的特点

a)  自反性：x.equals(x)应该返回true

b)  对称性：x.equals(y)为true，那么y.equals(x)也为true。

c)  传递性：x.equals(y)为 true并且y.equals(z)为true，那么x.equals(z)也应该为true。

d)  一致性：x.equals(y)的第一次调用为true，那么x.equals(y)的第二次、第三次、第n次调用也应该为true，前提条件是在比较之间没有修改x也没有修改y。

e)  对于非空引用x，x.equals(null)返回false。

3.  关于Object类的hashCode()方法的特点：

a)  在Java 应用的一次执行过程当中，对于同一个对象的hashCode方法的多次调用，他们应该返回同样的值（前提是该对象的信息没有发生变化）。

b)  对于两个对象来说，如果使用equals方法比较返回true，那么这两个对象的hashCode

值一定是相同的。

c)  对于两个对象来说，如果使用equals方法比较返回false，那么这两个对象的hashCode

值不要求一定不同（可以相同，可以不同），但是如果不同则可以提高应用的性能。

d)  对于Object类来说，不同的Object对象的hashCode值是不同的（Object类的hashCode

值表示的是对象的地址）。

 

补充：

24. 对于String类的equals()方法来说，重写了Object
中的equals()方法，  它是判断当前字符串与传进来的字符串的内容是否一致。对于String对象的相等性判断来说，请使用equals()方法，而不要使用==
。

而Object
中的 equals() 方法也是判断内容是否相等。Object
中的＝＝判断是否是同一个对象。

 

 

 

4.  当使用HashSet时，hashCode()方法就会得到调用，判断已经存储在集合中的对象的hashcode值是否与增加的对象的hash code值一致；如果不一致，直接加进去；如果一致，再进行equals方法的比较，equals方法如果返回true，表示对象已经加进去了，就不会再增加新的对象，否则加进去。

当使用HashSet 中的add() 方法时， 会自动调用Object中的 hashCode()
和 equals()
方法。所以必须同时重写这两个方法。

 

 

 

数组与collections的比较：

 

Class Array

java.lang.Object

  java.lang.reflect.Array

 

 

Class Collections

java.lang.Object

  java.util.Collections

 

以上两个类的所有方法都是静态的。

 

java.util

Interface Collection<E>     定义的方法都是非静态的。

 

ArrayList   LinkedList  都是 可以放相同元素  有下标  模仿 栈队列

 

HashSet    TreeSet    都是不可以放相同元素  无下标 
实现Comparator接口，升序 、降序 排列。

TreeSet 中有一个Comparator，策略模式。

 



 

 

5.  如果我们重写equals方法，那么也要重写hashCode方法，反之亦然。

 

6.  Map（映射）：Map的keySet()方法会返回key的集合，因为Map的键是不能重复的，因此keySet()方法的返回类型是Set；而Map的值是可以重复的，因此values()方法的返回类型是Collection，可以容纳重复的元素。

Map 中没有 add()
方法， 但是有 put() 方法。

 

Class HashMap<K,V>

java.lang.Object

  java.util.AbstractMap<K,V>

      java.util.HashMap<K,V>

 

遍历HashMap 的第一种方式 ：

 

HashMap map =new HashMap();

 

              map.put("a","aa");

              map.put("b","bb");

              map.put("c","cc");

                    

              Set set =
map.keySet();  // 先获取键的集合。

             

              for(Iteratoriter = set.iterator(); iter.hasNext();)

              {

                     String key = (String)iter.next();

                     String value = (String)map.get(key);

                    

                     System.out.println(key+ "=" + value);

              }

 

遍历HashMap 的第二种方式 ：

 

Set set = map.entrySet();  // 键和 值 一起拿到。

             

              for(Iteratoriter = set.iterator(); iter.hasNext();)

              {

                     Map.Entry entry = (Map.Entry)iter.next();

                    

                     Stringkey = (String)entry.getKey();

                     Stringvalue = (String)entry.getValue();

                    

                     System.out.println(key+ " : " + value);

              }