java静态集合_java 静态导入、可变参数、集合嵌套

一 静态导入

在导包的过程中我们可以直接导入静态部分，这样某个类的静态成员就可以直接使用了。

在源码中经常会出现静态导入。

静态导入格式：

import static XXX.YYY;   导入后YYY可直接使用。

Map.Entry的访问，简化后为Entry

import staticjava.util.Map.Entry;public classHashMapTest {public static voidmain(String[] args) {//1,创建hashmap集合对象。

Map map = new HashMap();//取出元素。键值对方式//Set> entrySet = map.entrySet();

Set> entrySet =map.entrySet();//for (Map.Entry entry : entrySet) {

for (Entryentry : entrySet) {

Student key=entry.getKey();

String value=entry.getValue();

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

}

}

}

二 可变参数

在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其

简化成如下格式：

修饰符 返回值类型 方法名(参数类型... 形参名){  }

其实这个书写完全等价与

修饰符 返回值类型 方法名(参数类型[] 形参名){  }

只是后面这种定义，在调用时必须传递数组，而前者可以直接传递数据即可。

jdk1.5以后。出现了简化操作... 用在参数上，称之为可变参数。

同样是代表数组，但是在调用这个带有可变参数的方法时，不用创建数组(这就是简单之处)，直接将

数组中的元素作为实际参数进行传递，其实编译成的class文件，将这些元素先封装到一个数组中，在进

行传递。这些动作都在编译.class文件时，自动完成了。

代码演示：

public classParamDemo {public static voidmain(String[] args) {int[] arr = {21,89,32};int sum =add(arr);

System.out.println(sum);

sum= add(21,89,32);//可变参数调用形式

System.out.println(sum);

}//JDK1.5之后写法

public static int add(int...arr){int sum = 0;for (int i = 0; i < arr.length; i++) {

sum+=arr[i];

}returnsum;

}//原始写法

/*public static int add(int[] arr) {

int sum = 0;

for (int i = 0; i < arr.length; i++) {

sum += arr[i];

}

return sum;

}*/}

上述add方法在同一个类中，只能存在一个。因为会发生调用的不确定性

注意：如果在方法书写时，这个方法拥有多参数，参数中包含可变参数，可变参数一定

要写在参数列表的末尾位置。

三  Collections集合工具类

Collections是集合工具类，用来对集合进行操作。部分方法如下：

public static void sort(List list) // 集合元素排序

//排序前元素list集合元素 [33,11,77,55]

Collections.sort( list );//排序后元素list集合元素 [11,33,55,77]

public static void shuffle(List> list) //  集合元素存储位置打乱

//list集合元素 [11,33,55,77]

Collections.shuffle( list );//使用shuffle方法后，集合中的元素为[77,33,11,55]，每次执行该方法，集合中存储的元素位置都会随机打乱

四 集合嵌套

集合嵌套并不是一个新的知识点，仅仅是集合内容又是集合，如Collection集合嵌套、Collection

集合与Map集合相互嵌套、Map集合嵌套。

ArrayList嵌套 ArrayList

ArrayList< ArrayList >

Collection< ArrayList >

Map嵌套 ArrayList

HashMap>

ArrayList< HashMap>

Map集合嵌套

HashMap>

HashMap>

map 集合嵌套的遍历

packagecom.oracle.demo02;importjava.util.HashMap;importjava.util.HashSet;importjava.util.Iterator;importjava.util.Map;importjava.util.Map.Entry;importjava.util.Set;importcom.oracle.demo01.Person;public classDemo04 {public static voidmain(String[] args) {

HashMap> oracle = newHashMap>();//造数据

HashMap java0512 = new HashMap();

java0512.put(new Person("小红",18),"优秀");

java0512.put(new Person("小白",20),"不及格");

HashMap java0715 = new HashMap();

java0715.put(new Person("小绿",25),"良好");

java0715.put(new Person("小黑",23),"及格");

oracle.put("java0512", java0512);

oracle.put("java0715", java0715);//keyset 增强for

/*Set bigkeyset = oracle.keySet();

for (String bigkey : bigkeyset) {

HashMap smallhm = oracle.get(bigkey);

Set smallkeyset = smallhm.keySet();

for (Person smallkey : smallkeyset) {

String smallvalue = smallhm.get(smallkey);

System.out.println(bigkey+"..."+smallkey+"..."+smallvalue);

}

}*/

//Iteratro

/*Set bigkeyset = oracle.keySet();

Iterator bigit = bigkeyset.iterator();

while(bigit.hasNext()){

String bigkey = bigit.next();

HashMap smallhm = oracle.get(bigkey);

Set smallkeyset = smallhm.keySet();

Iterator smallit = smallkeyset.iterator();

while (smallit.hasNext()) {

Person smallkey = smallit.next();

System.out.println(bigkey+"..."+smallkey+"..."+smallhm.get(smallkey));

}

}*/

//entry+增强for

/*Set>> bighmset = oracle.entrySet();

for (Entry> bighm : bighmset) {

String bigkey = bighm.getKey();

HashMap smallhm = bighm.getValue();

Set> smallhmset = smallhm.entrySet();

for (Entry smallhmen : smallhmset) {

Person smallkey = smallhmen.getKey();

String smallvalue = smallhmen.getValue();

System.out.println(bigkey+"..."+smallkey+"..."+smallvalue);

}

}*/

//iterator

/*Set>> bighmset = oracle.entrySet();

Iterator>> bigit = bighmset.iterator();

while (bigit.hasNext()) {

Entry> bighmen = bigit.next();

String bigkey = bighmen.getKey();

HashMap smallhm = bighmen.getValue();

Set> smallset = smallhm.entrySet();

Iterator> smallit = smallset.iterator();

while (smallit.hasNext()) {

Entry smallen = smallit.next();

Person smallkey = smallen.getKey();

String smallvaule = smallen.getValue();

System.out.println(bigkey+"..."+smallkey+"..."+smallvaule);

}

}*/

//keyset

/*Set bigset = oracle.keySet();

for (String bigkey : bigset) {

HashMap smallhm = oracle.get(bigkey);

Set smallset = smallhm.keySet();

for (Person smallkey : smallset) {

String smallvaule = smallhm.get(smallkey);

System.out.println(bigkey+" "+smallkey+" "+smallvaule);

}

}*/

/*Set bigset = oracle.keySet();

Iterator bigit = bigset.iterator();

while (bigit.hasNext()) {

String bigkey = bigit.next();

HashMap smallhm = oracle.get(bigkey);

Set smallset = smallhm.keySet();

Iterator smallit = smallset.iterator();

while (smallit.hasNext()) {

Person smallkey = smallit.next();

String smallvaule = smallhm.get(smallkey);

System.out.println(bigkey+" "+smallkey+" "+smallvaule);

}

}*/

//entry

/*Set>> bigset = oracle.entrySet();

for (Entry> bigen : bigset) {

String bigkey = bigen.getKey();

HashMap smallhm = bigen.getValue();

Set> smallset = smallhm.entrySet();

for (Entry smallen : smallset) {

Person smallkey = smallen.getKey();

String smallvaule = smallen.getValue();

System.out.println(bigkey+" "+smallkey+" "+smallvaule);

}

}*/Set>> bigset =oracle.entrySet();

Iterator>> bigit =bigset.iterator();while(bigit.hasNext()) {

Entry> bigen =bigit.next();

String bigkey=bigen.getKey();

HashMap smallhm =bigen.getValue();

Set> smallset =smallhm.entrySet();

Iterator> smallit =smallset.iterator();while(smallit.hasNext()) {

Entry smallen =smallit.next();

Person smallkey=smallen.getKey();

String smallvaule=smallen.getValue();

System.out.println(bigkey+" "+smallkey+" "+smallvaule);

}

}

}

}

五 集合继承体系的面向对象思想

接口：用来明确所有集合中该具有的功能，相当于在定义集合功能标准；

抽象类：把多个集合中功能实现方式相同的方法，抽取到抽象类实现，具体集合不再遍写，继承使用即可；

具体类：继承抽象类，实现接口，重写所有抽象方法，达到具备指定功能的集合。每个具体集合类，根据自

身的数据存储结构方式，对接口中的功能方法，进行不同方式的实现。