java 容器类的基本概念
java容器类类库的用途是“保存对象”，它们都可以自动地调整自己的尺寸。
java容器类可以划分为两个不同的概念：
- Collection。保存单一的元素。一个独立元素的序列，这些元素都服从一条或多条规则。
- List（列表）：必须按照插入的顺序保存元素。
- Set（集合）：不能有重复的元素。
- Queue（队列）：按照排队规则（默认被插入顺序）来确定对象产生的顺序。
- Map（映射）。保存相关联的键值对。一组成对的“键值对”对象，允许你使用键来查找值。
实例如下：
简单示例
// 简单示例
import java.util.*;
class SimpleCollection{
public static void main( String[] args ){
Collection< Integer > c = new ArrayList< Integer >();
for( int i = 0; i < 10; i ++ ) c.add( i );
for( Integer i : c ) System.out.print( i +" " ); // Foreach遍历
}
}
public class Test0527{
public static void main( String[] args ){
SimpleCollection.main( args );
}
}
---------------------
E:\java>java Test0527
0 1 2 3 4 5 6 7 8 9
添加一组元素
// 添加一组元素
import java.util.*;
class AddingGroups{
public static void main( String[] args ){
// Collection构造器( Collection对象 )初始化自身。
// Arrays.asList( 数组/逗号分隔的列表 )返回包含指定数组元素的固定大小列表
Collection< Integer > collection = new ArrayList< Integer >(Arrays.asList( 1, 2, 3, 4, 5 ));
System.out.println( collection );
Integer[] moreInts = { 6, 7, 8, 9, 10 };
collection.addAll( Arrays.asList( moreInts )); // Collection对象.addAll( 另一个Collection对象 )
System.out.println( collection );
// Collections.addAll( Collection对象，数组/逗号分隔的列表 ）将元素添加到Collection对象
Collections.addAll( collection, 11, 12, 13, 14, 15 );
System.out.println( collection );
Integer[] otheNums = { 16, 17, 18, 19, 20 };
Collections.addAll( collection, otheNums );
System.out.println( collection );
// Arrays.asList( 数组/逗号分隔的列表 )返回包含指定数组元素的固定大小列表
List< Integer > list = Arrays.asList( 1, 2, 3, 4, 6 );
System.out.println( list );
list.set( 4, 5 ); // 用指定元素替换指定位置的元素。固定位置范围：0 - 4。
System.out.println( list );
}
}
public class Test0603{
public static void main( String[] args ){
AddingGroups.main( args );
}
}
-----------------------------------------------------------------------
E:\java>java Test0603
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
[1, 2, 3, 4, 6]
[1, 2, 3, 4, 5]
import java.util.*;
class Snow{}
class Powder extends Snow{}
class Light extends Powder{}
class Heavy extends Powder{}
class Crusty extends Snow{}
class Slush extends Snow{}
class AsListInference{
public static void main( String[] args ){
List< Snow > snow1 = Arrays.asList( new Crusty(), new Slush(), new Powder() );
List< Snow > snow2 = new ArrayList< Snow >();
Collections.addAll( snow2, new Light(), new Heavy() );
// List< Snow > snow3 = Arrays.asList( new Light(), new Heavy() ); // 不兼容的类型
List< Snow > snow4 = Arrays.< Snow >asList( new Light(), new Heavy() );
}
}
容器的打印
// 容器的打印
import java.util.*;
class PrintingContainers{
static Collection fill( Collection< String > collection ){
collection.add( "rat" ); collection.add( "cat" );
collection.add( "dog" ); collection.add( "dog" );
return collection;
}
static Map fill( Map< String, String > map ){
map.put( "rat", "Fuzzy" ); map.put( "cat", "Rags" );
map.put( "dog", "Bosco" ); map.put( "dog", "Spot" );
return map;
}
public static void main( String[] args ){
System.out.println( fill( new ArrayList< String >()));
System.out.println( fill( new LinkedList< String >()));
System.out.println( fill( new HashSet< String >()));
System.out.println( fill( new TreeSet< String >()));
System.out.println( fill( new LinkedHashSet< String >()));
System.out.println( fill( new HashMap< String, String >()));
System.out.println( fill( new TreeMap< String, String >()));
System.out.println( fill( new LinkedHashMap< String, String >()));
}
}
public class Test0527{
public static void main( String[] args ){
PrintingContainers.main( args );
}
}
-------------------------------
E:\java>java Test0527
[rat, cat, dog, dog]
[rat, cat, dog, dog]
[cat, dog, rat]
[cat, dog, rat]
[rat, cat, dog]
{cat=Rags, dog=Spot, rat=Fuzzy}
{cat=Rags, dog=Spot, rat=Fuzzy}
{rat=Fuzzy, cat=Rags, dog=Spot}
List的典型用法
// List有两种类型
// ArrayList：长于随机访问元素，中间插入和移除元素较慢。
// LinkedList：随机访问较慢，但其他特性比ArrayList好。中间插入和移除元素较快，提供了优化的顺序访问。
import java.util.*;
class StringListFeatures{
static Random rand = new Random( 47 );
public static void main( String[] args ){
List< String > strs = new ArrayList< String >( Arrays.asList( "A", "B", "C", "D", "E", "F", "G" ) );
System.out.println( "strs: " + strs );
strs.add( "H" );
System.out.println( "strs.add( \"H\" ): " + strs );
System.out.println( "strs.contains( \"H\" ): " + strs.contains( "H" ) );
strs.remove( "H" );
System.out.println( "strs.remove( \"H\" ): " + strs );
String s1 = strs.get(2);
System.out.println( "strs.indexOf( strs.get( 2 )): " + strs.indexOf( s1 ) );
String s2 = "A";
System.out.println( "strs.indexOf( \"A\" ): " + strs.indexOf( s2 ) );
System.out.println( "strs.remove( s2 ) : " + strs.remove( s2 ) );
System.out.println( "strs.remove( s1 ) : " + strs.remove( s1 ) );
System.out.println( "strs: " + strs );
strs.add( 3, "0" );
System.out.println( "strs.add( 3, \"0\" ): " + strs );
List< String > sub = strs.subList( 1, 4 );
System.out.println( "strs.subList( 1, 4 ): " + sub );
System.out.println( "strs.containsAll( sub ): " + strs.containsAll( sub ) );
Collections.sort( sub );
System.out.println( "Collections.sort( sub ): " + sub );
System.out.println( "strs.containsAll( sub ): " + strs.containsAll( sub ) );
Collections.shuffle( sub, rand );
System.out.println( "Collections.shuffle( sub, rand ): "+ sub );
System.out.println( "strs.containsAll( sub ): " + strs.containsAll( sub ) );
List< String > copy = new ArrayList< String >( strs ); // 返回包含指定集合元素的列表。
sub = Arrays.asList( strs.get( 1 ), strs.get( 4 ) );
System.out.println( "Arrays.asList( strs.get( 1 ), strs.get( 4 ) ): " + sub );
copy.retainAll( sub );
System.out.println( "copy.retainAll( sub ): " + copy );
copy = new ArrayList< String >( strs );
System.out.println( "new ArrayList< String >( strs ): " + copy );
copy.remove( 2 );
System.out.println( "copy.remove( 2 ): " + copy );
copy.removeAll( sub );
System.out.println( "copy.removeAll( sub ): " + copy );
copy.set( 1, "I" );
System.out.println( "copy.set( 1, \"I\" ): " + copy );
copy.addAll( 2, sub );
System.out.println( "copy.addAll( 2, sub ): " + copy );
System.out.println( "strs.isEmpty(): " + strs.isEmpty() );
strs.clear();
System.out.println( "strs.clear(): " + strs );
System.out.println( "strs.isEmpty(): " + strs.isEmpty() );
strs.addAll( Arrays.asList( "A", "B", "C", "D" ) );
System.out.println( "strs.addAll( Arrays.asList( \"A\", \"B\", \"C\", \"D\" ) ): " + strs );
Object[] o = strs.toArray();
System.out.println( "strs.toArray()-o[3]: " + o[3] );
String[] sa = strs.toArray( new String[0] );
System.out.println( "strs.toArray( new String[0] )-sa[3]: " + sa[3] );
}
}
public class Test0527{
public static void main( String[] args ){
StringListFeatures.main( args );
}
}
--------------------------------------------------------------
E:\java>java Test0527
strs: [A, B, C, D, E, F, G] // 最初的List
strs.add( "H" ): [A, B, C, D, E, F, G, H] // 添加元素
strs.contains( "H" ): true // 判断元素是否在List
strs.remove( "H" ): [A, B, C, D, E, F, G] // 移除元素
strs.indexOf( strs.get( 2 )): 2 // 获得指定位置元素
strs.indexOf( "A" ): 0 // 获得指定元素第一次出现的索引，没有返回-1
strs.remove( s2 ) : true
strs.remove( s1 ) : true
strs: [B, D, E, F, G]
strs.add( 3, "0" ): [B, D, E, 0, F, G] // 指定位置添加元素
strs.subList( 1, 4 ): [D, E, 0] // 返回包含[1，4）之间元素的集合，包括1，不包括4的半区间
strs.containsAll( sub ): true // 判断是否包含指定集合
Collections.sort( sub ): [0, D, E] // 给指定列表排序
strs.containsAll( sub ): true // 元素顺序不影响判断包含关系
Collections.shuffle( sub, rand ): [D, 0, E] // 随机排列指定列表
strs.containsAll( sub ): true // 元素顺序不影响判断包含关系
Arrays.asList( strs.get( 1 ), strs.get( 4 ) ): [D, F] // 返回指定数组固定大小的列表
copy.retainAll( sub ): [D, F] // 只保留二个集合公共的元素
new ArrayList< String >( strs ): [B, D, 0, E, F, G]
copy.remove( 2 ): [B, D, E, F, G] // 移除指定位置元素
copy.removeAll( sub ): [B, E, G] // 移除指定集合包含的元素
copy.set( 1, "I" ): [B, I, G] // 给指定位置替换元素
copy.addAll( 2, sub ): [B, I, D, F, G] // 从指定位置插入指定集合元素
strs.isEmpty(): false // 判断列表是否为空
strs.clear(): [] // 清空列表元素
strs.isEmpty(): true
strs.addAll( Arrays.asList( "A", "B", "C", "D" ) ): [A, B, C, D] // 追加指定列表元素到末尾
strs.toArray()-o[3]: D // 返回包含列表元素的数组。
strs.toArray( new String[0] )-sa[3]: D
import java.util.*;
class LinkedListFeatures{
public static void main( String[] args ){
LinkedList< Integer > ints = new LinkedList< Integer >( Arrays.asList( 1, 2, 3, 4, 5 ) );
System.out.println( "ints: " + ints );
System.out.println( "ints.getFirst(): " + ints.getFirst() );
System.out.println( "ints.element(): " + ints.element() );
System.out.println( "ints.peek(): " + ints.peek() );
System.out.println( "ints.remove(): " + ints.remove() + " > " + ints);
System.out.println( "ints.removeFirst(): " + ints.removeFirst() + " > " + ints);
System.out.println( "ints.poll(): " + ints.poll() + " > " + ints );
ints.addFirst( 1 );
System.out.println( "ints.addFirst( 1 ): " + ints );
ints.offer( 2 );
System.out.println( "ints.offer( 2 ): " + ints );
ints.add( 3 );
System.out.println( "ints.add( 3 ): " + ints );
ints.addLast( 6 );
System.out.println( "ints.addLast( 6 ): " + ints );
System.out.println( "ints.removeLast(): " + ints.removeLast() + " > " + ints);
}
}
public class Test0527{
public static void main( String[] args ){
LinkedListFeatures.main( args );
}
}
------------------------------------------
E:\java>java Test0527
ints: [1, 2, 3, 4, 5]
ints.getFirst(): 1
ints.element(): 1
ints.peek(): 1
ints.remove(): 1 > [2, 3, 4, 5]
ints.removeFirst(): 2 > [3, 4, 5]
ints.poll(): 3 > [4, 5]
ints.addFirst( 1 ): [1, 4, 5]
ints.offer( 2 ): [1, 4, 5, 2]
ints.add( 3 ): [1, 4, 5, 2, 3]
ints.addLast( 6 ): [1, 4, 5, 2, 3, 6]
ints.removeLast(): 6 > [1, 4, 5, 2, 3]
Set的典型用法
// Set的典型用法
// HashSet
import java.util.*;
class SetOfInteger{
public static void main( String[] args ){
Random rand = new Random( 47 );
Set< Integer > intset = new HashSet< Integer >();
for( int i = 0; i < 10000; i ++ ) intset.add( rand.nextInt( 30 ) );
System.out.println( intset);
}
}
public class Test0528{
public static void main( String[] args ){
SetOfInteger.main( args );
}
}
--------------------------------------------------------------------------------
E:\java>java Test0528
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17, 16, 19, 18, 21, 20, 2
3, 22, 25, 24, 27, 26, 29, 28]
// TreeSet
import java.util.*;
class SortedSetOfInteger{
public static void main( String[] args ){
Random rand = new Random( 47 );
SortedSet< Integer > intset = new TreeSet< Integer >();
for( int i = 0; i < 10000; i ++ ) intset.add( rand.nextInt( 30 ) );
System.out.println( intset );
}
}
public class Test0528{
public static void main( String[] args ){
SortedSetOfInteger.main( args );
}
}
--------------------------------------------------------------------------------
E:\java>java Test0528
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 2
2, 23, 24, 25, 26, 27, 28, 29]
Queue的典型用法
import java.util.*;
class QueueDemo{ // 队列演示
public static void printQ( Queue queue ){
// peek()：返回队头或者null，element()：返回队头或者抛出NoSuchElementException异常。
// poll()：返回并移除队头或者null，remove()：返回并移除队头或者抛出NoSuchElementException异常。
while( queue.peek() != null ) System.out.print( queue.remove() + " " );
System.out.println();
}
public static void main( String[] args ){
Queue< Integer > queue = new LinkedList< Integer >(); // LinkedList实现了Queue接口，可以向上转型为Queue。
Random rand = new Random( 47 );
for( int i = 0; i < 10; i ++ ) queue.offer( rand.nextInt( i + 10 ) ); // offer()：将元素插到队尾，或者返回false。
printQ( queue );
Queue< Character > qc = new LinkedList< Character >();
// String.toCharArrya()：将字符串转换成字符数组。
for( char c : "Brontosaurus".toCharArray() ) qc.offer( c );
printQ( qc );
}
}
public class Test0604{
public static void main( String[] args ){
QueueDemo.main( args );
}
}
---------------------
E:\java>java Test0604
8 1 1 1 5 14 3 1 0 1
B r o n t o s a u r u s
import java.util.*;
class PriorityQueueDemo{ // 优先级队列演示
public static void main( String[] args ){
PriorityQueue< Integer > priorityQueue = new PriorityQueue< Integer >();
Random rand = new Random( 47 );
for( int i = 0; i < 10; i ++ ) priorityQueue.offer( rand.nextInt( i + 10 ) );
QueueDemo.printQ( priorityQueue );
List< Integer > ints = Arrays.asList( 25, 22, 20, 18, 14, 9, 3, 1, 1, 2, 3, 9, 14, 18, 21, 23, 25 );
priorityQueue = new PriorityQueue< Integer >( ints ); // 初始化自身。
QueueDemo.printQ( priorityQueue );
// Collections.reverseOrder()：返回反序比较器
// PriorityQueue( int, comparator )：按指定比较器对指定初始容量的元素进行排序的PriorityQueue。
priorityQueue = new PriorityQueue< Integer >( ints.size(), Collections.reverseOrder() );
priorityQueue.addAll( ints ); // 集合元素添加到指定集合里。
QueueDemo.printQ( priorityQueue );
}
}
public class Test0604{
public static void main( String[] args ){
PriorityQueueDemo.main( args );
}
}
--------------------------------------------
E:\java>java Test0604
0 1 1 1 1 1 3 5 8 14
1 1 2 3 3 9 9 14 14 18 18 20 21 22 23 25 25
25 25 23 22 21 20 18 18 14 14 9 9 3 3 2 1 1
Map的典型用法
import java.util.*;
class Statistics{ // 统计
public static void main( String[] args ){
Random rand = new Random( 47 );
Map< Integer, Integer > m = new HashMap< Integer, Integer >();
for( int i = 0; i < 10000; i ++ ){
int r = rand.nextInt( 20 ); // 随机取半区间[0,20)内的整数
Integer freq = m.get( r ); // 返回指定键映射的值或者null
m.put( r, freq == null ? 1 : freq + 1 );
}
System.out.println( m );
}
}
public class Test0604{
public static void main( String[] args ){
Statistics.main( args );
}
}
--------------------------------------------------------------------------------
E:\java>java Test0604
{0=481, 1=502, 2=489, 3=508, 4=481, 5=503, 6=519, 7=471, 8=468, 9=549, 10=513, 1
1=531, 12=521, 13=506, 14=477, 15=497, 17=509, 16=533, 19=464, 18=478}
import java.util.*;
class Pet{ // 宠物
private String name;
public Pet(){}
public Pet( String name ){ this.name = name; }
}
class Cat extends Pet{ // 猫
public Cat(){}
public Cat( String name ){ super( name ); }
}
class Dog extends Pet{ // 狗
public Dog(){}
public Dog( String name ){ super( name ); }
}
class Rodent extends Pet{ // 啮齿动物
public Rodent(){}
public Rodent( String name ){ super( name ); }
}
class Hamster extends Rodent{ // 仓鼠
public Hamster(){}
public Hamster( String name ){ super( name ); }
}
class PetMap{
public static void main( String[] args ){
Map< String, Pet > petMap = new HashMap< String, Pet >();
petMap.put( "My Cat", new Cat( "Molly" ) ); // put( K, V )：保存键值对
petMap.put( "My Dog", new Dog( "Ginger" ) );
petMap.put( "My Hamster", new Hamster( "Bosco" ) );
System.out.println( petMap );
Pet dog = petMap.get( "My Dog" ); // get( K )：返回键所对应的值（V）。
System.out.println( dog );
System.out.println( petMap.containsKey( "My Dog" ) ); // 映射包含指定键，返回true。
System.out.println( petMap.containsValue( dog ) ); // 映射有键映射到指定值，返回true。
}
}
public class Test0604{
public static void main( String[] args ){
PetMap.main( args );
}
}
-------------------------------------------------------------------
E:\java>java Test0604
{My Cat=Cat@1b67f74, My Dog=Dog@69b332, My Hamster=Hamster@173a10f}
Dog@69b332
true
true
import java.util.*;
class Person{
private String name;
public Person( String name ){ this.name = name; }
}
class Rat extends Rodent{ // 老鼠
public Rat(){}
public Rat( String name ){ super( name ); }
}
class Manx extends Cat{ // 曼岛猫
public Manx(){}
public Manx( String name ){ super( name ); }
}
class Cymric extends Manx{ // 威尔士猫
public Cymric(){}
public Cymric( String name ){ super( name ); }
}
class Pug extends Dog{ // 哈叭狗
public Pug(){}
public Pug( String name ){ super( name ); }
}
class Mutt extends Dog{ // 杂种狗
public Mutt(){}
public Mutt( String name ){ super( name ); }
}
class MapOfList{
public static Map< Person, List< ? extends Pet > > petPeople = new HashMap< Person, List< ? extends Pet > >();
static{
petPeople.put( new Person( "Dawn" ), Arrays.asList( new Cymric( "Molly" ), new Mutt( "Spot" ) ) );
petPeople.put( new Person( "Kate" ), Arrays.asList( new Cat( "Shackleton" ), new Cat( "Elsie May" ),
new Dog( "Margrett" ) ) );
petPeople.put( new Person( "Marilyn" ), Arrays.asList( new Pug( "Louie aka Louis Snorkelstein Dupree" ),
new Cat( "Stanford aka Stinky el Negro"), new Cat( "Pinkola" ) ) );
petPeople.put( new Person( "Luke" ), Arrays.asList( new Rat( "Fuzzy" ), new Rat( "Fizzy" ) ) );
petPeople.put( new Person( "Isaac" ), Arrays.asList( new Rat( "Freckly" ) ) );
}
public static void main( String[] args ){
System.out.println( "People: \n" + petPeople.keySet() ); // keySet()：返回键的Set视图
System.out.println( "Pets: \n" + petPeople.values() ); // values()：返回值的Collection视图
for( Person person : petPeople.keySet() ){
System.out.println( person + " has: " );
for( Pet pet : petPeople.get( person ) ) System.out.println( " " + pet );
}
}
}
public class Test0604{
public static void main( String[] args ){
MapOfList.main( args );
}
}
--------------------------------------------------------------------------------
E:\java>java Test0604
People:
[Person@1270b73, Person@530daa, Person@66848c, Person@8813f2, Person@a62fc3]
Pets:
[[Pug@1d58aae, Cat@83cc67, Cat@e09713], [Cymric@de6f34, Mutt@156ee8e], [Rat@47b4
80, Rat@19b49e6], [Rat@10d448], [Cat@e0e1c6, Cat@6ca1c, Dog@1bf216a]]
Person@1270b73 has:
Pug@1d58aae
Cat@83cc67
Cat@e09713
Person@530daa has:
Cymric@de6f34
Mutt@156ee8e
Person@66848c has:
Rat@47b480
Rat@19b49e6
Person@8813f2 has:
Rat@10d448
Person@a62fc3 has:
Cat@e0e1c6
Cat@6ca1c
Dog@1bf216a
Foreach和迭代器
// Foreach：主要用于数组，也可应用于任何Collection对象
import java.util.*;
class ForEachCollections{
public static void main( String[] args ){
Collection< String > cs = new LinkedList< String >();
//split( " " )：返回按空格分割字符串的字符串数组。
Collections.addAll( cs, "Take the long way home".split( " " ) ); // 添加指定元素到指定集合。
for( String s : cs ) System.out.print( "'" + s + "' " );
System.out.println( "\n" + cs );
}
}
public class Test0602{
public static void main( String[] args ){
ForEachCollections.main( args );
}
}
--------------------------------
E:\java>java Test0602
'Take' 'the' 'long' 'way' 'home'
[Take, the, long, way, home]
import java.util.*;
// 实现java.lang.Iterable< T >（可迭代的）接口，允许对象成为Foreach语句的目标。
class IterableClass implements Iterable< String >{
protected String[] words = ( "And what is how " + "we know the Earth to be banana-shaped." ).split( " " );
public Iterator< String > iterator(){ // 覆盖 iterator()方法返回Iterator（迭代器）
return new Iterator< String >(){ // 匿名内部类实现java.util.Iterator< E >接口
private int index = 0;
public boolean hasNext(){ return index < words.length; }
public String next(){ return words[ index ++ ]; }
public void remove(){ throw new UnsupportedOperationException(); } // 不支持移除操作,抛出不支持操作异常
};
}
public static void main( String[] args ){
for( String s : new IterableClass() ) System.out.print( s + " " ); // 对象执行Foreach语句
}
}
public class Test0602{
public static void main( String[] args ){
IterableClass.main( args );
}
}
----------------------------------------------------
E:\java>java Test0602
And what is how we know the Earth to be banana-shaped. // 我们怎么知道地球是香蕉形的呢？
// 显示操作系统环境变量
import java.util.*;
class EnvironmentVariables{ // 环境变量
public static void main( String[] args ){
// Map.Entry< K, V >：静态接口
// System.getenv()：返回当前系统环境的静态字符串映射视图（static Map< String, String >）。
// entrySet()：转换成Map.Entry< K, V >类型元素的Set集合，实现集合的迭代功能。
for( Map.Entry entry : System.getenv().entrySet() ){
System.out.println( entry.getKey() + ": " + entry.getValue() ); // 迭代输出键值对 K 和 V
}
}
}
public class Test0602{
public static void main( String[] args ){
EnvironmentVariables.main( args );
}
}
--------------------------------------------------------------------------------
E:\java>java Test0602
USERPROFILE: C:\Documents and Settings\Administrator
PATHEXT: .COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH
JAVA_HOME: C:\Program Files\Java\jdk1.6.0_45
=ExitCode: 00000000
TEMP: C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp
SystemDrive: C:
ProgramFiles: C:\Program Files
Path: C:\WINDOWS\system32;C:\Program Files\Java\jdk1.6.0_45\bin;C:\Program Files
\Java\jdk1.6.0_45\jre\bin;C:\Documents and Settings\Administrator\Local Settings
\Application Data\Kingsoft\WPS Office\11.1.0.8765\office6;C:\Program Files\JetBr
ains\IntelliJ IDEA 2019.1.2\bin;
HOMEDRIVE: C:
PROCESSOR_REVISION: 3a09
CLIENTNAME: Console
=C:: C:\Documents and Settings\Administrator
_DFX_INSTALL_UNSIGNED_DRIVER: 1
USERDOMAIN: QKPITV9TFQQ8YW7
ALLUSERSPROFILE: C:\Documents and Settings\All Users
WPS_HOME: C:\Documents and Settings\Administrator\Local Settings\Application Dat
a\Kingsoft\WPS Office\11.1.0.8765\office6
PROCESSOR_IDENTIFIER: x86 Family 6 Model 58 Stepping 9, GenuineIntel
=E:: E:\java
SESSIONNAME: Console
TMP: C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp
CommonProgramFiles: C:\Program Files\Common Files
CLASSPATH: .;C:\Program Files\Java\jdk1.6.0_45\lib;C:\Program Files\Java\jdk1.6.
0_45\lib\tools.jar;E:\java;
=::: ::\
LOGONSERVER: \\QKPITV9TFQQ8YW7
PROCESSOR_ARCHITECTURE: x86
FP_NO_HOST_CHECK: NO
OS: Windows_NT
HOMEPATH: \Documents and Settings\Administrator
PROMPT: $P$G
PROCESSOR_LEVEL: 6
COMPUTERNAME: QKPITV9TFQQ8YW7
windir: C:\WINDOWS
SystemRoot: C:\WINDOWS
IntelliJ IDEA: C:\Program Files\JetBrains\IntelliJ IDEA 2019.1.2\bin;
NUMBER_OF_PROCESSORS: 4
USERNAME: Administrator
ComSpec: C:\WINDOWS\system32\cmd.exe
APPDATA: C:\Documents and Settings\Administrator\Application Data
// foreach语句可以用于数组和Iterable,并不是说数组是Iterable的或者说会自动包装成Iterable。
import java.util.*;
class ArrayIsNotIterable{
static < T > void test( Iterable< T > ib ){
for( T t : ib ) System.out.print( t + " " );
}
public static void main( String[] args ){
test( Arrays.asList( 1, 2, 3 ) );
String[] s = { "A", "B", "C" };
// test( s ); // 错误：方法无法应用于String[]。 // 数组不是Iterable，也不会自动包装成Iterable。
test( Arrays.asList( s ) ); // 转换成Iterable
}
}
public class Test0602{
public static void main( String[] args ){
ArrayIsNotIterable.main( args );
}
}
---------------------
E:\java>java Test0602
1 2 3 A B C
import java.util.*;
class ReversibleArrayList< T > extends ArrayList< T >{ // 可逆数组列表 // 继承列表的正常迭代功能。
public ReversibleArrayList( Collection< T > c ){ super( c ); } // 创建一个有参构造器初始化列表。
public Iterable< T > reversed(){ // 反向（迭代）
return new Iterable< T >(){ // 匿名内部类实现可迭代接口
public Iterator< T > iterator(){
return new Iterator< T >(){ // 匿名内部类实现迭代器接口
int current = size() - 1; // size()：返回列表的元素数
public boolean hasNext(){ return current > -1; }
public T next(){ return get( current -- ); } // get()：返回指定位置元素。
public void remove(){ throw new UnsupportedOperationException(); }
};
}
};
}
}
class AdapterMethodIdiom{ // 适配器方法惯用法
public static void main( String[] args ){
ReversibleArrayList< String > r =
new ReversibleArrayList< String >( Arrays.asList( "To be or not to be".split( " " ) ) );
for( String s : r ) System.out.print( s + " " ); // 正常迭代
System.out.println();
for( String s : r.reversed() ) System.out.print( s + " " ); // 调用reversed()方法，返回一个反向的迭代器，实现反向迭代
}
}
public class Test0603{
public static void main( String[] args ){
AdapterMethodIdiom.main( args );
}
}
---------------------
E:\java>java Test0603
To be or not to be
be to not or be To
import java.util.*;
class IterableClass implements Iterable< String >{ // 实现Iterable接口，可以用foreach语句遍历元素。
protected String[] words = ( "And that is how " + "we know the Earth to be banana-shaped." ).split( " " );
public Iterator< String > iterator(){ // 正序（迭代）
return new Iterator< String >(){
private int index = 0;
public boolean hasNext(){ return index < words.length; }
public String next(){ return words[ index ++ ]; }
public void remove(){ throw new UnsupportedOperationException(); }
};
}
}
class MultiIterableClass extends IterableClass{ // 多重迭代类继承正序迭代
public Iterable< String > reversed(){ // 反向（迭代）
return new Iterable< String >(){
public Iterator< String > iterator(){
return new Iterator< String >(){
private int current = words.length - 1;
public boolean hasNext(){ return current > -1; }
public String next(){ return words[ current -- ]; }
public void remove(){ throw new UnsupportedOperationException(); }
};
}
};
}
public Iterable< String > randomized(){ // 随机（迭代）
return new Iterable< String >(){
public Iterator< String > iterator(){
List< String > shuffled = new ArrayList< String >( Arrays.asList( words ) );
Collections.shuffle( shuffled, new Random( 47 ) ); // 按指定随机源随机排列指定列表。
return shuffled.iterator(); // 返回一个正序迭代器。
}
};
}
public static void main( String[] args ){
MultiIterableClass m = new MultiIterableClass();
for( String s : m.reversed() ) System.out.print( s + " " ); // 反序
System.out.println();
for( String s : m.randomized() ) System.out.print( s + " " ); // 随机
System.out.println();
for( String s : m ) System.out.print( s + " " ); // 正序
}
}
public class Test0603{
public static void main( String[] args ){
MultiIterableClass.main( args );
}
}
------------------------------------------------------
E:\java>java Test0603
banana-shaped. be to Earth the know we how is that And
is banana-shaped. Earth that how the be And we know to
And that is how we know the Earth to be banana-shaped.
import java.util.*;
class ModifyingArrayAsList{ // 修改数组列表
public static void main( String[] args ){
Random rand = new Random( 47 ); // 随机源
Integer[] ia = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; // 数组
List< Integer > list1 = new ArrayList< Integer >( Arrays.asList( ia ) ); // 创建一个引用数组元素的ArrayList
System.out.println( "before: "+ list1 );
Collections.shuffle( list1, rand );
System.out.println( "shuffle: " + list1 );
System.out.println( "Array: " + Arrays.toString( ia ) ); // Collections.shuffle()打乱引用不会修改数组。
List< Integer > list2 = Arrays.asList( ia ); // 直接返回静态List
System.out.println( "before: " + list2 );
Collections.shuffle( list2, rand );
System.out.println( "shuffle: " + list2 );
System.out.println( "Array: " + Arrays.toString( ia ) ); // 直接使用Arrays.asList( ia )的结果，会修改数组。
}
}
public class Test0603{
public static void main( String[] args ){
ModifyingArrayAsList.main( args );
}
}
----------------------------------------
E:\java>java Test0603
before: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
shuffle: [4, 6, 3, 1, 8, 7, 2, 5, 10, 9]
Array: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
before: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
shuffle: [9, 1, 6, 3, 7, 2, 5, 10, 4, 8]
Array: [9, 1, 6, 3, 7, 2, 5, 10, 4, 8]
388
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
