<span style="font-family: Arial; font-size: 10px; ">//keySet集合测试
import java.util.*;
class KeySetDemo
{
public static void main(String[] args)
{
//创建Map集合，并添加元素
Map<Integer,String> map = new HashMap<Integer,String>();
map.put(2,"zhangsan");
map.put(6,"lisi");
map.put(3,"wangwu");
map.put(4,"heihei");
map.put(5,"xixi");
//获取map集合中的所有键的Set集合
Set<Integer> keySet = map.keySet();
//有了Set集合就可以获取其迭代器，取值
Iterator<Integer> it = keySet.iterator();
while (it.hasNext())
{
Integer i = it.next();
String s = map.get(i);
System.out.println(i + " = " + s);
}
}
}
</span><span style="font-family: Arial; font-size: 10px; ">/*
entrySet取出方式：
*/
import java.util.*;
class EntrySetDemo
{
public static void main(String[] args)
{
//创建集合，存入元素
Map<String,String> map = new HashMap<String,String>();
map.put("01","lisi1");
map.put("02","lisi2");
map.put("03","lisi3");
map.put("04","lisi4");
//获取map集合中的所有键，存入到Set集合中，
Set<Map.Entry<String,String>> entry = map.entrySet();
//通过迭代器取出map中的键值关系，迭代器接收的泛型参数应和Set接收的一致
Iterator<Map.Entry<String,String>> it = entry.iterator();
while (it.hasNext())
{
//将键值关系取出存入Map.Entry这个映射关系集合接口中
Map.Entry<String,String> me = it.next();
//使用Map.Entry中的方法获取键和值
String key = me.getKey();
String value = me.getValue();
System.out.println(key + " : " + value);
}
}
}
</span>练习
分析：
通过结果发现，每一个字母都有对应的次数。说明字母和次数之间都有映射关系。注意了，当发现有映射关系时，可以选择map集合。因为map集合中存放就是映射关系。
思路：
1，将字符串转换成字符数组。因为要对每一个字母进行操作。
2，定义一个map集合，因为打印结果的字母有顺序，所以使用treemap集合。
3，遍历字符数组。
将每一个字母作为键去查map集合。
如果返回null，将该字母和1存入到map集合中。
如果返回不是null，说明该字母在map集合已经存在并有对应次数。
那么就获取该次数并进行自增。，然后将该字母和自增后的次数存入到map集合中。覆盖调用原理键所对应的值。
4，将map集合中的数据变成指定的字符串形式返回。
<span style="font-family:Arial;font-size:10px;">import java.util.*;
class MapTest
{
public static void main(String[] args)
{
String s = "abcsjokafjoilnvoaxllvkasjdfnsde 0[fga8/-abbdc";
String str = LetterNum(s);
System.out.println(str);
}
public static String LetterNum(String str)
{
//将字符串转换成字符数组，因为对每个字母进行操作
char[] ch = str.toCharArray();
//定义一个Map集合，因为打印结果的字母有顺序，所以使用TreeMap集合
TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
int count = 0;
//遍历字符数组，将每一个字母作为键去查map集合，
for (int i=0;i<ch.length;i++)
{
//判断集合是否含有其他非字母，是则再次循环
if (!(ch[i]>= 'a' && ch[i] <= 'z' || ch[i] >= 'A' && ch[i] <= 'Z'))
continue;
//取出键对应的值，不为则计数器加1，存入集合，并将计数器清零，用于下一个字母
Integer value = tm.get(ch[i]);
if (value != null)
count = value;
count++;
tm.put(ch[i],count);
count = 0;
}
//创建字符串容器，存入取出的键值即按顺序排列的字符串
StringBuilder sb = new StringBuilder();
//迭代器取出相应键值，并存入字符串容器
Iterator<Map.Entry<Character,Integer>> it = tm.entrySet().iterator();
while (it.hasNext())
{
Map.Entry<Character,Integer> me = it.next();
Character key = me.getKey();
Integer value = me.getValue();
sb.append(key + "(" + value + ")");
}
return sb.toString();
}
}</span>在Collections工具类中很多方法是用于对List集合进行操作的，如比较，查找，随机排序等等
1、集合的各种方法：
1）查找：
T max(Collection<? extends T> coll) ---> 根据集合的自然顺序，获取coll集合中的最大元素
T max(Collection<? extends T> coll,Comparator<? super T> comp) ---> 根据指定比较器comp的顺序，获取coll集合中的最大元素
int binarySearch(Lsit<? extends Comparable<? super T>> list,Tkey) ---> 二分法搜索list集合中的指定对象2）替换：
void fill(List<? super T> list, T obj) ---> 将list集合中的全部元素替换成指定对象obj
boolean replaceAll(List<T> lsit,T oldVal,T newVal) ---> 使用newVal替换list集合中的oldVal值
3）排序：
void shuffle(List<?> list) ---> 使用默认随机源对list集合中的元素进行随机排序
void sort(Lsit<T> list) ---> 根据自然顺序对list集合中的元素进行排序
void sort(List<T> lsit,Comparator<? super T> c) ---> 根据指定比较器c的排序方式对list集合进行排序
4）反转
reverse(List<?> list) ---> 反转list集合中元素的顺序
Comparator reverseOrder() ---> 返回一个比较器，强行逆转了实现Comparable接口的对象的自然顺序
Comparator reverseOrder(Comparator<T> cmp) ---> 返回一个比较器，强行逆转了指定比较器的顺序
1、Lsit<T> asList(T... a) ---> 将数组转换为集合
注意：将数组转换成集合，不可使用集合的增删方法，因为数组的长度是固定的，如果进行增删操作，则会产生UnsupportedOperationException的编译异常。
a.如果数组中的元素都是对象，则变成集合时，数组中的元素就直接转为集合中的元素
b.如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在
2、binarySearch()：查找方法，fill()：替换方法，sort()：排序方法等
特点：可对数组元素进行相应操作，可以接受除boolean之外的其他各种基本数据类型及有序的引用类型数组的参数，且还可以对指定元素的范围，并可根据指定比较器进行相应的操作
如：sort(T[] a,Comparator<? super T> c)
fill(int[]a,int from,int to)等
3、String toString() 可以接收各种数组类型参数，并返回指定数组内容的字符串表现形式
4、集合转为数组
void toString(String[] s) ---> 将集合转为指定数组s，并可通过Arrays.toString(s)获取数组s中的元素
1）指定类型的数组定义的长度：
a.当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组，长度为集合的size
b.当指定类型的数组长度大于了集合的size，就不会创建数组，而是使用传递进来的数组，并且多出的元素的值为null
2）为何将集合转为数组：为了限定对集合中元素的操作，如增删，因为想对创建的集合不做增删方面的操作。
小知识点
一、增强for循环
1、格式：
for(数据类型 变量名 : 被遍历的集合（Collection）或数组){执行语句}
2、说明：
1）对集合进行遍历，只能获取集合的元素，但是不能对集合进行操作。
2）迭代器除了遍历外，还可进行remove集合中元素的操作，如果使用ListIterator，还可在遍历过程中，对集合进行增删改查的操作。
3、传统for循环和增强for循环区别：
增强for循环有局限性。必须有被遍历的目标；而传统for循环有索引。所以建议在遍历数组时，使用传统for循环。
示例：
<span style="font-family: Arial; font-size: 10px; ">import java.util.*;
class ForEachDemo
{
//打印方法
public static void sop(Object obj)
{
System.out.println(obj);
}
//测试
public static void main(String[] args)
{
//创建集合
ArrayList<String> as = new ArrayList<String>();
as.add("01-a");
as.add("02-b");
as.add("03-c");
System.out.println("原集合" + as);
//增强for循环取出元素
for (String s : as)
{
System.out.println(s);
}
System.out.println("-------------------------");
//创建HashMap集合
HashMap<Integer,String> hm = new HashMap<Integer,String>();
hm.put(1,"a");
hm.put(2,"b");
hm.put(3,"c");
hm.put(4,"d");
System.out.println("hm原集合：" + hm);
//增强for循环的两种方式测试
//keySet方法
sop("keySet方法:|--");
for(Integer i : hm.keySet())
{
sop(i + ":-" + hm.get(i));
}
//entrySet方法
sop("entrySet方法--");
for(Map.Entry<Integer,String> me : hm.entrySet())
{
sop(me.getKey() + "-->" + me.getValue());
}
}
}</span>二、可变参数：
如果在参数列表中传入多个参数，个数不确定，每次都要复写该方法，可变参数的出现就可以省去复写的麻烦，而直接对数组进行操作
注意：可变参数一定要定义在参数列表的后面。
示例：
<span style="font-family: Arial; "> ......
//1.5版本前写法
public static void show(int a,int b)
{
System.out.println(a + " :" + b);
}
//1.5新特性，可加入更多的值
public static void show(int... arr)
{
System.out.println(arr.length);//结果为数组arr的长度
System.out.println(arr);//arr的地址值
}
public static void print(String... s)
{
//遍历字符串数组s
for(String str : s)
{
System.out.print(str);
}
System.out.println();
}
......</span>三、静态导入：
静态导入，是将类中的所有静态成员导入进来，但需要注意的是，当导入的两个类中有同名成员时，需要在成员前加上相应的类名。
当类名重名时，需要制定具体的包名；当方法名重名时，制定具体所属的对象或类。
1、import static java.util.Arrays.*; ---> 写入的是Arrays类中的所有静态成员。
2、import static java.lang.System.*; ---> 导入了System类中的所有静态成员
<span style="font-family: Arial; font-size: 10px; ">import java.util.*;
import static java.util.Arrays.*;//导入的是Arrays类中的所有静态成员
import static java.lang.System.*;//导入的是System类中的所有静态成员
class Demo
{
public static void main(String [] args)
{
int[] arr = {2,7,6,3};
sort(arr);
out.println(Arrays.toString(arr));//此处不可省略Arrays，原因见下
}
}</span>详细请查看： http://edu.csdn.net
326
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
