------- android培训、java培训、期待与您交流! ----------
>> map集合
|--map集合:接口Map<K,V>//将键(key)映射到值(value)的对象,一个映射不能包含重复的键(键是唯一的),每个键最多只能映射到一个值。
map是双列集合,对应的collection是单列集合。
该集合存储键值对,一对一对往里面存,而且要保证键的唯一性。
|--HashTable:底层是哈希表数据结构,不可以存入null键和null值。该集合是线程同步的。jdk1.0效率低
|--properties: 用于配置文件的定义和操作,使用频率非常高,同时键和值都是字符串。
是集合中可以和IO技术相结合的对象。 到了IO在学习它的特有和io相关的功能。
|--HashMap:底层是哈希表数据结构,允许存入null键和null值。该集合是不同步的。jdk1.2,效率高。是无序的。
|--LinkedHashMap
|--TreeMap:底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。
实际上,Set底层就是使用了Map集合。
>>功能
1、添加
V put(K key,V value)//将指定的值与此映射中的指定键关联(可选操作)。
void putAll(Map<? extends K,?extends V> m)//从指定映射中将所有映射关系复制到此映射中
补充:为什么put返回V而putAll为void呢?因为put方法将k和v作为元素存储如map集合,当存入了相同的k时,新的值会覆盖原来的值,并返回原来的值。
2、删除
void clear()//从此映射中移除所有映射关系(可选操作)。
V remove(Object key)//如果存在一个键的映射关系,则将其从此映射中移除(可选操作)。
3、判断
boolean containsValue(Object value)//如果此映射将一个或多个键映射到指定值,则返回 true。
boolean containsKey(Object key)//如果此映射包含指定键的映射关系,则返回 true。
boolean isEmpty()//如果此映射未包含键-值映射关系,则返回 true。
补充:凡是“is”打头的方法,返回值几乎是boolean型的。
4、获取
V get(Object key)//返回指定键所映射的值;如果此映射不包含该键的映射关系,则返回null。
int size()//返回此映射中的键-值映射关系数。
Collection<V> values()//返回此映射中包含的值的 Collection 视图。
重点
Set<Map.Entry<K,V>> entrySet()//返回此映射中包含的映射关系的 Set 视图。
Set<K> keySet()//返回此映射中包含的键的 Set 视图。
5、Map没有迭代器
迭代器是collection集合有的,Map集合的取出元素的原理:就是将Map集合先转成Set集合,再进行迭代。
>>eg:基本演示
importjava.util.*
classMapDemo
{
public static void main(String[] args)
{
Map<String,String> map= new HashMap<String,String>();//泛型
//添加元素
map.put(“01”,”zhangsan1”);
map.put(“02”,”zhangsan2”);
System.out.println(map.put(“03”,”zhangsan3”));//返回null
System.out.println(map.put(“01”,zhangsan88));//返回zhangsan1
Systme.out.println(“containsKey:”+map.containsKey(“022”));
Systme.out.println(“remove:”+map.remove(“02”));
Systme.out.println(map);//打印,结果02消失
Systme.out.println(“get:”+map.get(“023”));//结果null
//特殊情况
map.put(null,”kong”);//HashMap可以存入空键
//map.put(“04”,null);
Systme.out.println(“get:”+map.get(null));//结果输出kong
//可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。
//获取Map集合中所有的值
Collection<String> coll= map.values()
Systme.out.println(coll);//输出值,无序
Systme.out.println(map);//输出键值对,无序
/*特殊:put方法*/
Systme.out.println(“put:”+map.put(“01”,zhangsanBbb));//返回zhangsan1
Systme.out.println(“put:”+map.put(“01”,wangwu));//返回zhangsanBbb
/*添加相同的键,原有值被覆盖了,返回被替换的值*/
}
}
>>map集合的两种取出方式:
1,Set<k> keySet:将map中所有的键存入到Set集合。因为set具备迭代器。所有可以迭代方式取出所有的键,再根据get方法。获取每一个键对应的值。
Map集合的取出原理:将map集合转成set集合。在通过迭代器取出。
eg: import java.util.*;
class MapDemo2
{
publicstatic void main(String[] args)
{
Map<String,String>map = new HashMap<String,String>();
map.put("02","zhangsan2");
map.put("03","zhangsan3");
map.put("01","zhangsan1");
map.put("04","zhangsan4");
//先获取map集合的所有键的Set集合,keySet();
Set<String>keySet = map.keySet();
//有了Set集合。就可以获取其迭代器。
Iterator<String>it = keySet.iterator();
while(it.hasNext())
{
Stringkey = it.next();//取键
//有了键可以通过map集合的get方法获取其对应的值。
Stringvalue = map.get(key);//取值
System.out.println("key:"+key+",value:"+value);
}
}
}
2,Set<Map.Entry<k,v>>entrySet:将map集合中的映射关系存入到了set集合中,而这个关系的数据类型就是:Map.Entry
上面的意思其实是:将map集合中的键值关系取出,并封装成一个键值关系对象。再存储到一个set集合中。键值映射关系封装对象后的数据类型是:Map.Entry。如果是键是丈夫,值是妻子,那么键值映射关系封装对象就是结婚证。
entry其实就是Map中的一个static内部接口。为什么要定义在内部呢?因为只有有了Map集合,有了键值对,才会有键值的映射关系。关系属于Map集合中的一个内部事物。而且该事物在直接访问Map集合中的元素。
eg: import java.util.*;
class MapDemo2
{
publicstatic void main(String[] args)
{
Map<String,String>map = new HashMap<String,String>();
map.put("02","zhangsan2");
map.put("03","zhangsan3");
map.put("01","zhangsan1");
map.put("04","zhangsan4");
//将Map集合中的映射关系取出。存入到Set集合中。
Set<Map.Entry<String,String>>entrySet = map.entrySet();
//泛型嵌套形式,Map是一个接口,Entry是它的内部接口
Iterator<Map.Entry<String,String>>it = entrySet.iterator();
while(it.hasNext())
{
Map.Entry<String,String>me = it.next();
Stringkey = me.getKey();
Stringvalue = me.getValue();
System.out.println(key+":"+value);
}
/*
//先获取map集合的所有键的Set集合,keySet();
Set<String>keySet = map.keySet();
//有了Set集合。就可以获取其迭代器。
Iterator<String>it = keySet.iterator();
while(it.hasNext())
{
Stringkey = it.next();
//有了键可以通过map集合的get方法获取其对应的值。
Stringvalue = map.get(key);
System.out.println("key:"+key+",value:"+value);
}
*/
}
}
Map.Entry 其实Entry也是一个接口,它是Map接口中的一个内部接口。
interface Map
{
publicstatic interface Entry//作为子接口,而且被静态修饰的一定是内部接口
{
publicabstract Object getKey();
publicabstract Object getValue();
}
}
class HashMap implements Map
{
classHahs implements Map.Entry
{
public Object getKey(){}
public Object getValue(){}
}
}
>>Map例子
每一个学生都有对应的归属地。
学生Student,地址String。
学生属性:姓名,年龄。
注意:姓名和年龄相同的视为同一个学生。
保证学生的唯一性。
1,描述学生。
2,定义map容器。将学生作为键,地址作为值。存入。
3,获取map集合中的元素。
import java.util.*;
class Student implementsComparable<Student>//实现接口,注意泛型
{
privateString name;
privateint age;
Student(Stringname,int age)
{
this.name= name;
this.age= age;
}
publicint compareTo(Student s)//覆盖方法
{
intnum = new Integer(this.age).compareTo(new Integer(s.age));
if(num==0)
returnthis.name.compareTo(s.name);
returnnum;
//整合if语句
//returnnum==0? this.name.compareTo(s.name):num;
}
publicint hashCode()//覆盖方法
{
returnname.hashCode()+age*34;
}
publicboolean equals(Object obj)//覆盖方法
{
if(!(objinstanceof Student))
thrownew ClassCastException("类型不匹配");//返回false改成抛出异常
Students = (Student)obj;
returnthis.name.equals(s.name) && this.age==s.age;
}
publicString getName()
{
returnname;
}
publicint getAge()
{
returnage;
}
publicString toString()
{
returnname+":"+age;
}
}
class MapTest
{
publicstatic void main(String[] args)
{
HashMap<Student,String>hm = new HashMap<Student,String>();
hm.put(newStudent("lisi1",21),"beijing");
hm.put(newStudent("lisi1",21),"tianjin");
hm.put(newStudent("lisi2",22),"shanghai");
hm.put(newStudent("lisi3",23),"nanjing");
hm.put(newStudent("lisi4",24),"wuhan");
//第一种取出方式keySet
Set<Student>keySet = hm.keySet();
Iterator<Student>it = keySet.iterator();
while(it.hasNext())
{
Studentstu = it.next();
Stringaddr = hm.get(stu);
System.out.println(stu+".."+addr);
}
//第二种取出方式entrySet
Set<Map.Entry<Student,String>>entrySet = hm.entrySet();
Iterator<Map.Entry<Student,String>>iter = entrySet.iterator();
while(iter.hasNext())
{
Map.Entry<Student,String>me = iter.next();
Studentstu = me.getKey();
Stringaddr = me.getValue();
System.out.println(stu+"........."+addr);
}
}
}
eg:排序还可以引入比较器
/*
需求:对学生对象的姓名进行升序排序。
因为数据是以键值对形式存在的。
所以要使用可以排序的Map集合。TreeMap。
*/
import java.util.*;
class StuNameComparator implementsComparator<Student>//比较器类
{
publicint compare(Student s1,Student s2)
{
intnum = s1.getName().compareTo(s2.getName());
if(num==0)
returnnew Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
returnnum;
}
}
class MapTest2
{
publicstatic void main(String[] args)
{
TreeMap<Student,String>tm =
new TreeMap<Student,String>(new StuNameComparator());//载入比较器
tm.put(newStudent("blisi3",23),"nanjing");
tm.put(newStudent("lisi1",21),"beijing");
tm.put(newStudent("alisi4",24),"wuhan");
tm.put(newStudent("lisi1",21),"tianjin");
tm.put(newStudent("lisi2",22),"shanghai");
Set<Map.Entry<Student,String>>entrySet = tm.entrySet();
Iterator<Map.Entry<Student,String>>it = entrySet.iterator();
while(it.hasNext())
{
Map.Entry<Student,String>me = it.next();
Studentstu = me.getKey();
Stringaddr = me.getValue();
System.out.println(stu+":::"+addr);
}
}
}
>>例子
eg:
需求:"sdfgzxcvasdfxcvdf"获取该字符串中的字母出现的次数。
希望打印结果:a(1)c(2).....
分析:通过结果发现,每一个字母都有对应的次数。
说明字母和次数之间都有映射关系。
注意了,当发现有映射关系时,可以选择map集合。
因为map集合中存放就是映射关系。
思路:第一次用“s”字母作为键去找集和。那么集合没有“s”这个键,座椅也没有对应的次数。返回null。如果为null,就将“s”字母和1(次数)存入集合。如果指定的键(比如“s”)已经存在,就将对应的次数取出,自增,重新存入集合。
1,将字符串转换成字符数组。因为要对每一个字母进行操作。
2,定义一个map集合,因为打印结果的字母有顺序,所以使用treemap集合。
3,遍历字符数组。
将每一个字母作为键去查map集合。
如果返回null,将该字母和1存入到map集合中。
如果返回不是null,说明该字母在map集合已经存在并有对应次数。
那么就获取该次数并进行自增。,然后将该字母和自增后的次数存入到map集合中。覆盖调用原理键所对应的值。
4,将map集合中的数据变成指定的字符串形式返回。
import java.util.*;
class MapTest3
{
publicstatic void main(String[] args)
{
Strings= charCount("ak+abAf1c,dCkaAbc-defa");
System.out.println(s);
}
publicstatic String charCount(String str)
{
char[]chs = str.toCharArray();
TreeMap<Character,Integer>tm = new TreeMap<Character,Integer>();
intcount = 0;
for(intx=0; x<chs.length; x++)
{
if(!(chs[x]>='a'&& chs[x]<='z' || chs[x]>='A' && chs[x]<='Z'))
continue;
Integervalue = tm.get(chs[x]);
if(value!=null)
count= value;//取出次数
count++;
tm.put(chs[x],count);
//直接往集合中存储字符和数字,为什么可以,因为自动装箱。
count= 0;//为下一次使用准备
/*
if(value==null)
{
tm.put(chs[x],1);
}
else
{
value= value + 1;
tm.put(chs[x],value);
}
*/
}
//System.out.println(tm);
StringBuildersb = new StringBuilder();
Set<Map.Entry<Character,Integer>>entrySet = tm.entrySet();
Iterator<Map.Entry<Character,Integer>> it = entrySet.iterator();
while(it.hasNext())
{
Map.Entry<Character,Integer>me = it.next();
Characterch = me.getKey();
Integervalue = me.getValue();
sb.append(ch+"("+value+")");
}
returnsb.toString();
}
}
>>map集合拓展知识
map集合使用是因为具备映射关系
eg:1班,1号,aaa
1班,2号,bbb
2班,1号,aa
2班,2号,bb
这样有两组对应关系,大集合(班与学号、名字的映射)里嵌套小集合(学号和名字的映射)。
class QianTao
{
public static void main(String[] args)
{
//学号、姓名映射
HashMap<String,String>oneBan = new HashMap<String,String>();
oneBan.put(“1号”,”aaa”);
oneBan.put(“2号”,”bbb”);
HashMap<String,String> twoBan= new HashMap<String,String>();
oneBan.put(“1号”,”aa”);
oneBan.put(“2号”,”bb”);
//班级与学号、姓名映射
HashMap<String,HashMap<String,String>>banJi
= newHashMap<String,HashMap<String,String>>();//注意此映射的值
banJi.put(“oneBan”,oneBan);
banJi.put(“twoBan”,twoBan);
//我想取出某班级所有学生信息
getStudentInfo(oneBan);
//我想取出全部学生的信息
//遍历所有banJim集合,获取所有班级
Iterator<String>it = banJi.keySet().iterator();
while(it.hasNext())
{
String roomName = it.next();
HashMap<String,String> room =banJi.get(roomName);
//Systme.out.println(roomName);
//使用班级获取学生
getStudentInfo(roomName);
}
public staticvoid getStudentInfo(HashMap<String,String> roomMap)
{
Iterator<String> it =roomMap.keySet().iterator();
while(it.hasNext())
{
String id = it.next;
String name =roomMap.get(id);
System.out.println(id+”:”+name);
}
}
}
如果将学号和姓名封装成一个学生类(Student)对象呢?还可以用集合么?
eg:import java.util.*;
class Student
{
privateString id;
privateString name;
Student(Stringid,String name)
{
this.id= id;
this.name= name;
}
publicString toString()
{
returnid+":::"+name;
}
}
class MapDemo
{
publicstatic void demo()
{
HashMap<String,List<Student>>czbk = new HashMap<String,List<Student>>();
List<Student>reyu = new ArrayList<Student>();
List<Student>jiuye = new ArrayList<Student>();
czbk.put("yureban",reyu);
czbk.put("jiuyeban",jiuye);
reyu.add(newStudent("01","zhagnsa"));
reyu.add(newStudent("04","wangwu"));
jiuye.add(newStudent("01","zhouqi"));
jiuye.add(newStudent("02","zhaoli"));
Iterator<String>it = czbk.keySet().iterator();
while(it.hasNext())
{
StringroomName = it.next();
List<Student>room = czbk.get(roomName);
System.out.println(roomName);
getInfos(room);
}
}
publicstatic void getInfos(List<Student> list)
{
Iterator<Student>it = list.iterator();
while(it.hasNext())
{
Students = it.next();
System.out.println(s);
}
}
>>工具类utilities
|--Collections,其中方法皆为静态,因为没有特有数据,所以直接调用,不用创建对象
|--Arrays,其中方法皆为静态,所以直接调用,不用创建对象
>> Collection与Collections有什么区别?比如现在有一些元素,不需要保证唯一,所以用List,但是我又想排序,不能用tree了,tree属于set集合。Collections提供了集合的操作工具。其中
static<T extends Comparable<? super T>> void sort(List<T> list)
//根据元素的自然顺序 对指定列表按升序进行排序。
static<T> void sort(List<T> list, Comparator<? super T> c)
//根据指定比较器产生的顺序对指定列表进行排序。
解决这个问题
eg:import java.util.*
class CollectionsDemo
{
publicstatic void main(String[] args)
{
sortDemo();
}
publicstatic void sortDemo()
{
List<String>list = new ArrayList<String>();//数组结构
list.add(“a”);
list.add(“c”);
list.add(“b”);
list.add(“z”);
list.add(“g”);
list.add(“z”);//重复?可以排序,有索引!
sop(list);
Collections.sort(list);//注意,不能给set排序,只能用于List
sop(list);
Collections.sort(list,newStrLenComparator());
sop(list);
}
public staticvoid sop(Object obj)
{
System.out.println(obj);
}
}
//依据字符串长度排序,使用比较器
class StrLenComparator implementsComparator<String>
{
publicint compare(String s1,String s2)
{
if(s1.length()>s2.length())
return1;
if(s1.length()<s2.length())
return-1;
returns1.compareTo(s2);
}
}
>>使用sort方法排序,但是希望从z输出,于是,在collections中有一个方法:
static<T> Comparator<T> reverseOrder()
//返回一个比较器,它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
eg:………………
Collections.sort(arrayList,Collections.reverseOrder());
………………
还有其他的形式:
Collections.sort(list,Collections.reverseOrder(newStrLenComparator()));
//也可以逆转自定义的比较器
如果是SetTree容器,本身就有排序功能,也可以逆转
eg:………………
TreeSet<String>ts = new TreeSet<String>(Collections.reverseOrder());
………………
>>static <T extends Object &Comparable<? super T>> T max(Collection<? extends T> coll)
//根据元素的自然顺序,返回给定 collection 的最大元素。
public staticvoid maxDemo()
{
List<String>list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");
//Stringmax = Collections.max(list,new StrLenComparator());//返回最大长度
Stringmax = Collections.max(list);
sop("max="+max);
}
>> static <T> intbinarySearch(List<? extends Comparable<? super T>> list, T key)
//使用二分搜索法搜索指定列表,以获得指定对象。
注意,其中,只能对List进行支持,因为二分查找需要角标
eg: public static void binarySearchDemo()
{
List<String>list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");
//二分法针对的是有序的集合,故而先排序
Collections.sort(list,newStrLenComparator());
sop(list);
//intindex = Collections.binarySearch(list,"aaaa");
/*
结果为负数,意思是没有查到,并指示插入位置
注意,这里指示的插入位置是:插入点-1!
为什么减一呢?是防止插入点为0,而方法想定义负数是没有找到!
所以如果指示-3,其实插入点为2。
当然,也可以传自定义的比较器
*/
intindex = halfSearch2(list,"aaaa",new StrLenComparator());
sop("index="+index);
}
原理:
public staticint halfSearch(List<String> list,String key)
{
intmax,min,mid;
max= list.size()-1;
min= 0;
while(min<=max)
{
mid= (max+min)>>1;// 右移,除以2
Stringstr = list.get(mid);
intnum = str.compareTo(key);
if(num>0)
max= mid -1;
elseif(num<0)
min= mid + 1;
else
returnmid;
}
return-min-1;//返回插入点
}
原理,带比较器
public staticint halfSearch2(List<String> list,String key,Comparator<String>cmp)
{
intmax,min,mid;
max= list.size()-1;
min= 0;
while(min<=max)
{
mid= (max+min)>>1;// /2;
Stringstr = list.get(mid);
intnum = cmp.compare(str,key);
if(num>0)
max = mid -1;
elseif(num<0)
min= mid + 1;
else
returnmid;
}
return-min-1;
}
>>一些其它方法
staticvoid reverse(List<?> list) //反转指定列表中元素的顺序。
staticvoid swap(List<?> list, int i, int j) //在指定列表的指定位置处交换元素。
staticvoid shuffle(List<?> list, Random rnd) //使用指定的随机源对指定列表进行置换。好玩
static<T> boolean replaceAll(List<T> list, T oldVal, T newVal) //使用另一个值替换列表中出现的所有某一指定值。
重点:将不同步的集合转换成同步的
static<T> Collection<T> synchronizedCollection(Collection<T> c) //返回指定collection 支持的同步(线程安全的)collection。
static<T> List<T> synchronizedList(List<T> list) //返回指定列表支持的同步(线程安全的)列表。
static<K,V> Map<K,V> synchronizedMap(Map<K,V> m) //返回由指定映射支持的同步(线程安全的)映射。
static<T> Set<T> synchronizedSet(Set<T> s) //返回指定 set 支持的同步(线程安全的)set。
static<K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m) //返回指定有序映射支持的同步(线程安全的)有序映射。
static<T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s) //返回指定有序 set 支持的同步(线程安全的)有序 set。
>>Arrays中的方法,有大面积重载
binarySeach、fill、sort(还可以分段排序)、copyOf、
static boolean deepEquals(Object[] a1, Object[] a2) //如果两个指定数组彼此是深层相等 的,则返回 true。具体就是比较两个数组是否有相同对象且对象中的元素是否相同
static <T> List<T> asList(T... a) //返回一个受指定数组支持的固定大小的列表。
//即将数组变成集合
eg:………………
public staticvoid main(String[] args)
{
//Arrays中有一个重要的方法,将数组变成集合。
String[] arr = {"haha","hehe","heihei"};
List<String>list = Arrays.asList(arr);//数组转成集合。
/*
当数组变成集合后,就可以使用集合的方法来操作数组。
而不用自己在定义指针进行数组的操作。(或者for)
但是有些方法不可以用,只要改变集合长度的方法
都不能用,因为数组是固定长度的。
*/
boolean b =list.contains("hehe");
//list.add(“xixi”);//编译错误
………………
………………
int[] arr ={3,4,6};
//当数组中元素是引用数据类型时,变成集合后,就将数组中的元素作为集合中的元素存在。
//但是集合中不能存储基本数据类型!
//当数组中的元素是基本数据类型时,变成集合后,会将“这个数组”变成集合中的元素。
List<int[]>list = Arrays.asList(arr);//注意这里的泛型
………………
toString方法,将数组变成字符串
eg:………………
System.out.println(Arrays.toString(arr));//将数组直接变成字符串。
………………
>>Collection中的方法,集合转数组
<T> T[] toArray(T[] a)//返回包含此 collection 中所有元素的数组;返回数组的运行时类型与指定数组的运行时类型相同。
方便在于传入什么类型,返回什么类型!
eg:
import java.util.*;
class CollectionToArray
{
public staticvoid main(String[] args)
{
ArrayList<String>al = new ArrayList<String>();
al.add("haha");
al.add("hehe");
al.add("heihei");
String[] arr= al.toArray(new String[al.size()]);//将集合变成数组。
/*
给toArray方法传递指定类型的数组。
长度该怎么定义呢?
当指定的长度小于集合的长度,String[] arr = al.toArray(0);
该方法内部会自动创建一个该类型的新数组长度和集合长度一致 。用于存储集合中的元素。
如果指定的数组长度大于集合的长度,String[] arr = al.toArray(5);
那么该方法就不会创建新数组。而是使用传递进来的数组,
存储完集合的元素后,其他的未存储的位置为null。
所以在定义数组是,最好定义长度和集合长度相同的数组。这样就不用创建新数组了。
而且也不会出现空位为null。
将集合变成数组有什么用呢?
其实是限定了对元素的增删操作。
*/
System.out.println(Arrays.toString(arr));
}
}
>>一些JDK1.5以后的新特性
>>Collection 继承了Iterable接口,Iterable对Iterator方法进行了抽取,主要是为了以后的扩展。
同时,实现Iterable接口可以使用“foreach”,即增强for循环。
格式:for( 元素类型 变量 : 数组或者Collection集合)
{
}
增强for循环和传统for循环有什么不同呢?
增强for循环,使用时,必须要有被遍历的目标。而且只能遍历数组和Collection集合。简化了迭代。传统for循环,它的应用更为普遍。注意:建议遍历数组还是使用传统for循环,可以通过指针对数组元素进行操作。这个升级是注重简化书写。
eg:……………………
public staticvoid main(String[] args)
{
ArrayList<String>al = new ArrayList<String>();
al.add("haha");
al.add("hehe");
al.add("heihei");
for(String s: al)//高级for循环一般只用于遍历。不对元素进行操作。
{
System.out.println(s);
}
………………
eg:………………
int[] arrayx = {3,4,5,6};
for(intabb:arrayx)
{
//System.out.println(abb);
abb= 10;
}
System.out.println(Arrays.toString(arrayx));//将数组变成字符串输出
………………
//结果输出:[3,4,5,6]
abb是局部变量,数组不变
要对map集合进行遍历,可以使用foreach循环吗?
不可以直接使用。但是可以间接使用。可以将map集合转成set结合,在使用foreach循环。
eg:
import java.util.*;
class ForeachDemo
{
public staticvoid main(String[] args)
{
ArrayList<String>al = new ArrayList<String>();
al.add("aaa1");
al.add("aaa2");
al.add("aaa3");
al.add("aaa4");
al.add("aaa5");
for(Strings:al)
{
System.out.println(s);
}
//遍历数组
int[] arr=new int[3];
int[] arrayx= {3,4,5,6};
for(intabb:arrayx)
{
System.out.println(abb);
}
//对map集合进行操作
HashMap<String,String>hm = new /*Linked*/HashMap<String,String>();
//要按照输入顺序输出?把HashMap加上Linked
hm.put("1","aa");
hm.put("2","bb");
hm.put("3","cc");
hm.put("4","dd");
hm.put("5","ee");
Set<String>keySet = hm.keySet();//转成Set集合
//第一种遍历方法
for(Strings:keySet)
{
System.out.println("key:"+s+"-value:"+hm.get(s));
}
//第二种遍历方法
for(Map.Entry<String,String>me:hm.entrySet())
{
//System.out.println(me);
Stringkey = me.getKey();
Stringvalue = me.getValue();
System.out.println(key+"--"+value);
}
}
}
>>可变类型参数
通常,一个方法这样定义
public intvoid show(int x,int y){return 1;}
如果参数较多
public intvoid show(int[] arr){return 1;}
但是上面这个需要传入数组,意味着要new一个数组传入,麻烦
所以还可以这样定义,在指定数据类型的后面加上三个点 ,其实就是一个数组类型的参数。
public staticvoid show(int... arr)//可变参数。其实arr就是一个数组类型的参数。
{
for(inti : arr)
{
System.out.println(i);
}
}
那么,在main中可以这样调用:
show(3);
或
show(3,5,1,6,8,9);
但是,简化的操作一定有局限性,比如,如果这样书写
public staticvoid show(int... arr, int temp){}
结果编译错误,因为有可能参数都被存入arr数组,temp就什么都没有接收到了,所以
注意:如果函数上有多个参数,可变参数一定要定义在参数列表最后面。
public staticvoid show(int temp ,int... arr){}
否则编译失败。
另外,如果我多此一举,传入一个数组呢?
eg:import java.util.*;
class ParamterDemo
{
public staticvoid main(String[] args)
{
int[] arr = {1,2,3,4};//建立一个数组
show(arr);//传入
show(1,2,3,4);
}
public staticvoid show(int... arr)//定义的可变参数
{
System.out.println(Arrays.toString(arr));
/*
for(intout:arr)
{
System.out.println(out);
}
*/
}
}
这样也是可以的,正常的编译和运行输出。
>>静态导入
eg:import java.util.*;//简化类名的书写。
import static java.util.Collections.*;//导入了一个类中的所有静态成员.
import static java.util.Arrays.*;
import static java.lang.System.*;//System.out.println()
class StaticImportDemo
{
public staticvoid main(String[] args)
{
/*java.util.*/ArrayList<Integer>al = new ArrayList<Integer>();
al.add(1);
al.add(4);
al.add(6);
al.add(2);
sort(al);
System.out.println(al);
int index =binarySearch(al,4);
System.out.println("index="+index);
int[] arr ={4,1,6};
sort(arr);//和Collections的sort传的参数不一样,不冲突
System.out.println(Arrays.toString(arr));
//这里的“toString”和Object中的冲突,需加上Arrays
out.println("haha");//导入了System
}
}