chap17.code

Eclipse+Web开发从入门到精通 These files contain all of the code listings in Java: The Complete Referenc

listing 1
// Demonstrate ArrayList. 
import java.util.*; 
 
class ArrayListDemo { 
  public static void main(String args[]) { 
    // Create an array list. 
    ArrayList<String> al = new ArrayList<String>(); 
     
    System.out.println("Initial size of al: " + 
                       al.size()); 
 
    // Add elements to the array list. 
    al.add("C"); 
    al.add("A"); 
    al.add("E"); 
    al.add("B"); 
    al.add("D"); 
    al.add("F"); 
    al.add(1, "A2"); 
 
    System.out.println("Size of al after additions: " + 
                       al.size()); 
 
    // Display the array list. 
    System.out.println("Contents of al: " + al); 
 
    // Remove elements from the array list. 
    al.remove("F"); 
    al.remove(2); 
 
    System.out.println("Size of al after deletions: " + 
                       al.size()); 
    System.out.println("Contents of al: " + al); 
  } 
}

listing 2
// Convert an ArrayList into an array.  
import java.util.*;  
  
class ArrayListToArray {  
  public static void main(String args[]) {  
    // Create an array list. 
    ArrayList<Integer> al = new ArrayList<Integer>();  
      
    // Add elements to the array list. 
    al.add(1);  
    al.add(2);  
    al.add(3);  
    al.add(4);  
  
    System.out.println("Contents of al: " + al);  
  
    // Get the array. 
    Integer ia[] = new Integer[al.size()];  
    ia = al.toArray(ia);  
  
    int sum = 0;  
  
    // Sum the array. 
    for(int i : ia) sum += i;  
  
    System.out.println("Sum is: " + sum);  
  }  
}

listing 3
// Demonstrate LinkedList. 
import java.util.*; 
 
class LinkedListDemo { 
  public static void main(String args[]) { 
    // Create a linked list. 
    LinkedList<String> ll = new LinkedList<String>(); 
     
    // Add elements to the linked list. 
    ll.add("F"); 
    ll.add("B"); 
    ll.add("D"); 
    ll.add("E"); 
    ll.add("C"); 
    ll.addLast("Z"); 
    ll.addFirst("A"); 
 
    ll.add(1, "A2"); 
 
    System.out.println("Original contents of ll: " + ll); 
 
    // Remove elements from the linked list. 
    ll.remove("F"); 
    ll.remove(2); 
 
    System.out.println("Contents of ll after deletion: " 
                       + ll); 
 
    // Remove first and last elements. 
    ll.removeFirst(); 
    ll.removeLast(); 
 
    System.out.println("ll after deleting first and last: " 
                       + ll); 
 
    // Get and set a value. 
    String val = ll.get(2); 
    ll.set(2, val + " Changed"); 
 
    System.out.println("ll after change: " + ll); 
  } 
}

listing 4
// Demonstrate HashSet. 
import java.util.*; 
 
class HashSetDemo { 
  public static void main(String args[]) { 
    // Create a hash set. 
    HashSet<String> hs = new HashSet<String>(); 
     
    // Add elements to the hash set. 
    hs.add("B"); 
    hs.add("A"); 
    hs.add("D"); 
    hs.add("E"); 
    hs.add("C"); 
    hs.add("F"); 
 
    System.out.println(hs); 
  } 
}

listing 5
// Demonstrate TreeSet. 
import java.util.*; 
 
class TreeSetDemo { 
  public static void main(String args[]) { 
    // Create a tree set. 
    TreeSet<String> ts = new TreeSet<String>(); 
     
    // Add elements to the tree set. 
    ts.add("C"); 
    ts.add("A"); 
    ts.add("B"); 
    ts.add("E"); 
    ts.add("F"); 
    ts.add("D"); 
 
    System.out.println(ts); 
  } 
}

listing 6
// Demonstrate iterators. 
import java.util.*; 
 
class IteratorDemo { 
  public static void main(String args[]) { 
    // Create an array list. 
    ArrayList<String> al = new ArrayList<String>(); 
     
    // Add elements to the array list. 
    al.add("C"); 
    al.add("A"); 
    al.add("E"); 
    al.add("B"); 
    al.add("D"); 
    al.add("F"); 
 
    // Use iterator to display contents of al. 
    System.out.print("Original contents of al: "); 
    Iterator<String> itr = al.iterator(); 
    while(itr.hasNext()) { 
      String element = itr.next(); 
      System.out.print(element + " "); 
    } 
    System.out.println(); 
 
    // Modify objects being iterated. 
    ListIterator<String> litr = al.listIterator();  
    while(litr.hasNext()) { 
      String element = litr.next(); 
      litr.set(element + "+"); 
    } 
 
    System.out.print("Modified contents of al: "); 
    itr = al.iterator();  
    while(itr.hasNext()) { 
      String element = itr.next(); 
      System.out.print(element + " "); 
    } 
    System.out.println(); 
 
    // Now, display the list backwards. 
    System.out.print("Modified list backwards: "); 
    while(litr.hasPrevious()) { 
      String element = litr.previous(); 
      System.out.print(element + " "); 
    } 
    System.out.println(); 
  } 
}

listing 7
// Use the for-each for loop to cycle through a collection. 
import java.util.*; 
 
class ForEachDemo { 
  public static void main(String args[]) { 
    // Create an array list for integers. 
    ArrayList<Integer> vals = new ArrayList<Integer>(); 
     
    // Add values to the array list. 
    vals.add(1); 
    vals.add(2); 
    vals.add(3); 
    vals.add(4); 
    vals.add(5); 
 
    // Use for loop to display the values. 
    System.out.print("Original contents of vals: "); 
    for(int v : vals)  
      System.out.print(v + " "); 
    System.out.println(); 
 
    // Now, sum the values by using a for loop. 
    int sum = 0; 
    for(int v : vals)  
      sum += v; 
 
    System.out.println("Sum of values: " + sum); 
  } 
}

listing 8
// A simple mailing list example.  
import java.util.*;  
  
class Address {  
  private String name;  
  private String street;  
  private String city;  
  private String state;  
  private String code;  
  
  Address(String n, String s, String c,   
          String st, String cd) {  
    name = n;  
    street = s;  
    city = c;  
    state = st;  
    code = cd;  
  }  
  
  public String toString() {  
    return name + "\n" + street + "\n" +  
           city + " " + state + " " + code;  
  }  
}  
  
class MailList {  
  public static void main(String args[]) {  
    LinkedList<Address> ml = new LinkedList<Address>();  
      
    // Add elements to the linked list. 
    ml.add(new Address("J.W. West", "11 Oak Ave",  
                       "Urbana", "IL", "61801"));  
    ml.add(new Address("Ralph Baker", "1142 Maple Lane",  
                       "Mahome", "IL", "61853"));  
    ml.add(new Address("Tom Carlton", "867 Elm St",  
                       "Champaign", "IL", "61820"));  
 
    // Display the mailing list. 
    for(Address element : ml) 
      System.out.println(element + "\n");  
 
    System.out.println();  
  }  
}

listing 9
import java.util.*;  
  
class HashMapDemo {  
  public static void main(String args[]) {  
  
    // Create a hash map. 
    HashMap<String, Double> hm = new HashMap<String, Double>();  
      
    // Put elements to the map  
    hm.put("John Doe", new Double(3434.34));  
    hm.put("Tom Smith", new Double(123.22));  
    hm.put("Jane Baker", new Double(1378.00));  
    hm.put("Tod Hall", new Double(99.22));  
    hm.put("Ralph Smith", new Double(-19.08));  
  
    // Get a set of the entries. 
    Set<Map.Entry<String, Double>> set = hm.entrySet();  
 
    // Display the set. 
    for(Map.Entry<String, Double> me : set) { 
      System.out.print(me.getKey() + ": ");  
      System.out.println(me.getValue());  
    }  
 
    System.out.println();  
  
    // Deposit 1000 into John Doe's account. 
    double balance = hm.get("John Doe");  
    hm.put("John Doe", balance + 1000);  
 
    System.out.println("John Doe's new balance: " +  
      hm.get("John Doe"));  
  }  
}

listing 10
import java.util.*;  
  
class TreeMapDemo {  
  public static void main(String args[]) {  
  
    // Create a tree map. 
    TreeMap<String, Double> tm = new TreeMap<String, Double>();  
      
    // Put elements to the map. 
    tm.put("John Doe", new Double(3434.34));  
    tm.put("Tom Smith", new Double(123.22));  
    tm.put("Jane Baker", new Double(1378.00));  
    tm.put("Tod Hall", new Double(99.22));  
    tm.put("Ralph Smith", new Double(-19.08));  
  
    // Get a set of the entries. 
    Set<Map.Entry<String, Double>> set = tm.entrySet(); 
  
    // Display the elements. 
    for(Map.Entry<String, Double> me : set) { 
      System.out.print(me.getKey() + ": ");  
      System.out.println(me.getValue());  
    }  
    System.out.println();  
 
    // Deposit 1000 into John Doe's account. 
    double balance = tm.get("John Doe");  
    tm.put("John Doe", balance + 1000);  
 
    System.out.println("John Doe's new balance: " +  
      tm.get("John Doe"));  
  }  
}

listing 11
// Use a custom comparator.  
import java.util.*;  
  
// A reverse comparator for strings.  
class MyComp implements Comparator<String> {  
  public int compare(String a, String b) {  
    String aStr, bStr;  
  
    aStr = a;  
    bStr = b;  
  
    // Reverse the comparison. 
    return bStr.compareTo(aStr);  
  }  
  
  // No need to override equals.  
}  
  
class CompDemo {  
  public static void main(String args[]) {  
    // Create a tree set. 
    TreeSet<String> ts = new TreeSet<String>(new MyComp());  
      
    // Add elements to the tree set. 
    ts.add("C");  
    ts.add("A");  
    ts.add("B");  
    ts.add("E");  
    ts.add("F");  
    ts.add("D");  
  
    // Display the elements. 
    for(String element : ts) 
      System.out.print(element + " ");  
 
    System.out.println();  
  }  
}


listing 12
// Use a comparator to sort accounts by last name.  
import java.util.*;  
  
// Compare last whole words in two strings.  
class TComp implements Comparator<String> {  
  public int compare(String a, String b) {  
    int i, j, k;  
    String aStr, bStr;  
  
    aStr = a;  
    bStr = b;  
  
    // Find index of beginning of last name. 
    i = aStr.lastIndexOf(' ');  
    j = bStr.lastIndexOf(' ');  
  
    k = aStr.substring(i).compareTo(bStr.substring(j));  
    if(k==0) // last names match, check entire name  
      return aStr.compareTo(bStr);  
    else  
      return k;  
  }  
  
  // No need to override equals.  
}  
  
class TreeMapDemo2 {  
  public static void main(String args[]) {  
    // Create a tree map. 
    TreeMap<String, Double> tm = new TreeMap<String, Double>(new TComp());  
      
    // Put elements to the map. 
    tm.put("John Doe", new Double(3434.34));  
    tm.put("Tom Smith", new Double(123.22));  
    tm.put("Jane Baker", new Double(1378.00));  
    tm.put("Tod Hall", new Double(99.22));  
    tm.put("Ralph Smith", new Double(-19.08));  
  
    // Get a set of the entries.  
    Set<Map.Entry<String, Double>> set = tm.entrySet();  
  
    // Display the elements. 
    for(Map.Entry<String, Double> me : set) { 
      System.out.print(me.getKey() + ": ");  
      System.out.println(me.getValue());  
    }  
    System.out.println();  
  
    // Deposit 1000 into John Doe's account. 
    double balance =  tm.get("John Doe");  
    tm.put("John Doe", balance + 1000);  
 
    System.out.println("John Doe's new balance: " +  
      tm.get("John Doe"));  
  }  
}

listing 13
// Demonstrate various algorithms.  
import java.util.*;  
  
class AlgorithmsDemo {  
  public static void main(String args[]) {  
  
    // Create and initialize linked list. 
    LinkedList<Integer> ll = new LinkedList<Integer>();  
    ll.add(-8);  
    ll.add(20);  
    ll.add(-20);