------<ahref="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流! -------
黑马程序员——19,Collections工具类,Arrays工具类
/*
Collections是一个类,注意,这里后面带有一个s
千万不要和Collection弄混了!Collection只是接口而已。
两者要区别开来。
Collections是一个工具类。
这个类里面全部方法都是静态的,可以直接类名调用。
什么时候用到这个工具类呢?
例如,List集合里面可以有重复元素,但是想要对这些元素排列的话,怎么办?
这个时候就要用到这个工具类了。
这个工具类就是专门针对集合进行操作的工具类。
例如这个工具类里面有一个定义好的静态方法sort
public static <T extend Comparable<? super T>> void sort(List<T> list)
调用的时候直接Collections.sort(li);
其中,li是List<Teacher>的实例,那么这就要求Teacher类的对象本身要具备比较性
还有一个常用的方法
public static <T>void sort(List<T>list, Comparator<? super T> c)
调用的时候直接Collections.sort(li,compa);
其中,li是List<Teacher>的实例,
而compa是实现了Comparator接口的子类的实例,
这个比较器操作的是Teacher类或者Teacher类的子类的对象。
那么这个时候,就会按照比较器的规则来对元素排序。
*/
import java.util.*; class Je { public static void main(String[] args) { method(fh()); method2(fh()); method3(fh()); System.out.println("HelloWorld!"); } public static List<String> fh() { List<String> biaoge=new ArrayList<String>(); biaoge.add("bfuibag"); biaoge.add("ibu"); biaoge.add("ibu");//注意这里有重复元素 biaoge.add("uitweru"); biaoge.add("fvgfiberbrt"); biaoge.add("zz"); biaoge.add("juykui"); soc("原本biaoge---"+biaoge);//先打印原本顺序的biaoge return biaoge; } public static void method(List<String> biaoge) { soc("下面是method------"); Collections.sort(biaoge);//按照元素的自然顺序排列 soc("新排列biaoge---"+biaoge); //接着再打印使用Collections.sort()方法排列好的biaoge //String类的对象字符串本身就具备比较性 //使用Collections.sort()进行排序,遇到了重复元素也不会剔除掉的 } public static void method2( List<String> biaoge) { soc("下面是method2------"); Collections.sort(biaoge,new Bijiao());//按照比较器比较排列 soc("新排列biaoge---"+biaoge); //这里即便是使用比较器比较,重复元素也不会被剔除 } public static void method3(List<String> biaoge) { //取得最大值 soc("下面是method3------"); String max=Collections.max(biaoge); //按照元素自然顺序取得最大值,注意并不是按照角标取最大值! soc("max="+max); Collections.sort(biaoge); max=Collections.max(biaoge); soc("max="+max); max=Collections.max(biaoge,new Bijiao()); //按照比较器取得最大值 soc("max="+max); } public static void soc(Object obj) { System.out.println(obj); } } class Bijiao implements Comparator<String> { public int compare(String s1,String s2) { if(s1.length()>s2.length()) { return 1; } if(s1.length()==s2.length()) { return s1.compareTo(s2); } return -1; } } /* 以上代码编译运行结果; 原本biaoge---[bfuibag,ibu, ibu, uitweru, fvgfiberbrt, zz, juykui] 下面是method------ 新排列biaoge---[bfuibag,fvgfiberbrt, ibu, ibu, juykui, uitweru, zz] 原本biaoge---[bfuibag,ibu, ibu, uitweru, fvgfiberbrt, zz, juykui] 下面是method2------ 新排列biaoge---[zz, ibu,ibu, juykui, bfuibag, uitweru, fvgfiberbrt] 原本biaoge---[bfuibag,ibu, ibu, uitweru, fvgfiberbrt, zz, juykui] 下面是method3------ max=zz max=zz max=fvgfiberbrt Hello World! */
——————分割线——————
/* Collections中的常用方法的调用 */ import java.util.*; class Je2 { public static void main(String[] args) { fillDemo(fh()); replaceAllDemo(fh()); reverseDemo(fh()); reverseOrderDemo(); } public static List<String> fh() { List<String> biaoge=new ArrayList<String>(); biaoge.add("bfuibag"); biaoge.add("ibu"); biaoge.add("ibu");//注意这里有重复元素 biaoge.add("cfff"); biaoge.add("zz"); biaoge.add("rrr"); biaoge.add("juykui"); return biaoge; } public static void binarySearchDemo(List<String> biaoge) { soc("下面是binarySearchDemo---"); Collections.sort(biaoge);//排序 soc(biaoge); int jb= Collections.binarySearch(biaoge,"rrr") ; //用折半查找法在biaoge中寻找"ddd",返回对应的角标 soc("jb="+jb); int cz= Collections.binarySearch(biaoge,"rkk") ; soc("cz="+cz);//这句话打印的是cz=-6 /* 用Collections.binarySearch()找不到列表中的元素时候, 返回的一定是负数,负号表示不存在,之后的数值是如果 不影响元素排列顺序的话合适的插入位置。 Set集合有内部隐藏自己的排列方式,所以该方法是用于List集合的。 如果元素本身不具备比较性,可以加一个比较器,写法如下: int cz=Collections.binarySearch(biaoge,"rkk",biComparator) ; 其中biComparator是实现了Comparator<String>接口 */ } public static void fillDemo(List<String> biaoge) { soc("下面是fillDemo---"); soc("原本的biaoge---"+biaoge); Collections.fill(biaoge,"yyyyyy");//把所有元素替换成"yyyyyy" soc(biaoge); } public static void replaceAllDemo(List<String> biaoge) { soc("下面是replaceAllDemo---"); soc("原本的biaoge---"+biaoge); Collections.replaceAll(biaoge,"rrr","kkk"); //把rrr替换成了kkk,按照元素替换元素非常方便 soc(biaoge); } public static void reverseDemo(List<String> biaoge) { soc("下面是reverseDemo---"); soc("原本的biaoge---"+biaoge); Collections.reverse(biaoge);//把List集合的元素翻转排列 soc("reverse后的biaoge---"+biaoge); } public static void reverseOrderDemo() { soc("下面是reverseOrderDemo---"); TreeSet<String> tg=new TreeSet<String>(); tg.add("bfuibag"); tg.add("ibu"); tg.add("ibu");//注意这里有重复元素 tg.add("cfff"); tg.add("zz"); tg.add("rrr"); tg.add("juykui"); soc("下面是没有加Collections.reverseOrder()的TreeSet集合tg"); soc(tg); TreeSet<String> ts=new TreeSet<String>(Collections.reverseOrder()); ts.add("bfuibag"); ts.add("ibu"); ts.add("ibu");//注意这里有重复元素 ts.add("cfff"); ts.add("zz"); ts.add("rrr"); ts.add("juykui"); soc("下面是加了反向比较器后ts"); soc(ts); /* Collections.reverseOrder()会返回一个反向比较器,这里打印出来的都是反向 还有一种用法举一个例子: TreeSet<String> ts=new TreeSet<String>(Collections.reverseOrder(ggg)); 其中ggg是本人随便取名的比较器,这个比较器有自己的规则,但是 Collections.reverseOrder(ggg)把ggg的规则翻转了,那么传给new TreeSet<String>的 规则就是翻转ggg比较规则之后的规则。 */ } public static void soc(Object obj) { System.out.println(obj); } } /* 以上代码编译运行结果: 下面是fillDemo--- 原本的biaoge---[bfuibag,ibu, ibu, cfff, zz, rrr, juykui] [yyyyyy, yyyyyy, yyyyyy, yyyyyy, yyyyyy,yyyyyy, yyyyyy] 下面是replaceAllDemo--- 原本的biaoge---[bfuibag,ibu, ibu, cfff, zz, rrr, juykui] [bfuibag, ibu, ibu, cfff, zz, kkk, juykui] 下面是reverseDemo--- 原本的biaoge---[bfuibag,ibu, ibu, cfff, zz, rrr, juykui] reverse后的biaoge---[juykui, rrr, zz, cfff, ibu, ibu, bfuibag] 下面是reverseOrderDemo--- 下面是没有加Collections.reverseOrder()的TreeSet集合tg [bfuibag, cfff, ibu, juykui, rrr, zz] 下面是加了反向比较器后ts [zz, rrr, juykui, ibu, cfff, bfuibag] */
————————分割线————————
/* Collections工具类里面的一些常用方法 */ import java.util.*; class Je3 { public static void main(String[] args) { swapDemo(fh()); shuffleDemo(fh()); } public static List<String> fh() { List<String> biaoge=new ArrayList<String>(); biaoge.add("bfuibag"); biaoge.add("ibu"); biaoge.add("ibu");//注意这里有重复元素 biaoge.add("cfff"); biaoge.add("zz"); biaoge.add("rrr"); biaoge.add("juykui"); return biaoge; } public static void swapDemo(List<String> biaoge) { soc("下面是swapDemo---"); soc(biaoge); Collections.swap(biaoge,3,4); //换位操作,把第三位和第四位换一下位置 soc("换位后的biaoge---"+biaoge); } public static void shuffleDemo(List<String> biaoge) { soc("下面是shuffleDemo---"); soc(biaoge); Collections.shuffle(biaoge); //把元素顺序打乱 soc(biaoge); } public static void soc(Object obj) { System.out.println(obj); } } /* 以上代码编译运行结果: 下面是swapDemo--- [bfuibag, ibu, ibu, cfff, zz, rrr, juykui] 换位后的biaoge---[bfuibag,ibu, ibu, zz, cfff, rrr, juykui] 下面是shuffleDemo--- [bfuibag, ibu, ibu, cfff, zz, rrr, juykui] [rrr, juykui, ibu, cfff, ibu, zz, bfuibag] */
————————分割线————————
/*
Arrays类也是一个工具类针对数组操作的工具类。
Arrays类里面的都是静态类。
*/
import java.util.*; class Je4 { public static void main(String[] args) { toStringDemo(); asListDemo(); } public static void asListDemo() { soc("下面是asListDemo---"); String[] s={"sdf","hjk","yuiio"}; List<String> k= Arrays.asList(s); //k.add("kiuh"); /* 把数组s转换成了List集合, 但是由数组转成集合后不能对其进行增加或者删减操作,否则运行时异常 因为数组长度已经是固定好的了。 这里的数组里面的元素时String型,就是对象。 当数组里面元素时对象的时候,调用这个方法就可以直接转成List集合。 */ soc("k---"+k); int[] s2={12,36,14,45}; List k2=Arrays.asList(s2); //此句等同于List<int[]> k2=Arrays.asList(s2); soc("k2---"+k2); /* 这里打印出来的是数组对应的哈希值, 如果数组中的元素为基本数据类型, Arrays.asList()方法就会把整个数组作为一个元素存进List集合里面。 */ Integer[] s3={5,14,78,5,4}; //该数组元素是对象,注意分清。 List<Integer> k3=Arrays.asList(s3); soc("k3---"+k3); } public static void toStringDemo() { soc("下面是toStringDemo---"); int[] x={12,85,4,74,32,46}; soc(Arrays.toString(x)); //Arrays.toString(x)返回的是数组x的信息 } public static void soc(Object obj ) { System.out.println(obj ); } } /* 以上代码编译运行结果: 下面是toStringDemo--- [12, 85, 4, 74, 32, 46] 下面是asListDemo--- k---[sdf, hjk, yuiio] k2---[[[email protected]] k3---[5, 14, 78, 5, 4] */
————————分割线————————
/* 集合转成数组: */ import java.util.*; class Je5 { public static void main(String[] args) { List<String> s=new ArrayList<String>(); s.add("sss01"); s.add("sss02"); s.add("sss03"); s.add("sss04"); soc("s---"+s); String[] z= s.toArray(new String[7]); /* toArray()方法是Collection接口的方法。 如果没有new String[7]就会运行时候报错, 因为to Array()方法返回的是Object类对象的数组。 加入new String[7]后会建立并且返回一个长度为7的String类型数组, []里的长度过长就会填充null,如果长度过短就又会新建一个合适长度的数组。 为了节约资源,应该刚好填合适长度的。 例如在这道题中,应该这么写: String[] z=s.toArray(new String[s.length()]); 集合转成数组之后就不能增加删减操作了。 这也是为了限制对元素的操作。 */ soc("z---"+Arrays.toString(z)); } public static void soc(Object obj) { System.out.println(obj); } } /* 以上代码编译运行结果: s---[sss01, sss02, sss03, sss04] z---[sss01, sss02, sss03, sss04, null,null, null] */
——————分割线——————
/*
高级for循环
for(数据类型 变量名:被遍历的集合或者数组)
{
语句;
}
高级for循环是从jdk1.5版本出现的,底层调用了迭代器
高级for循环不能对角标进行操作,这也是其不足之处。
*/
import java.util.*; class Je6 { publicstatic void main(String[] args) { List<String> s=new ArrayList<String>(); s.add("hjk"); s.add("yhdn"); s.add("vgbda"); s.add("tr"); for(String a: s) { a="233"; soc(a); } soc(s); /*这一点要注意: a原本只是指向被遍历对象而已,即便a被赋值了, 依旧没有改变被遍历对象里面的值。 */ for(String a: s) { soc(a); } soc(s); Map<String,String> m=new HashMap<String,String>() ; m.put("yu01","李四"); m.put("yu12","小姐"); m.put("yu3","大炮"); m.put("yu45","红的"); Set<Map.Entry<String,String>> rt = m.entrySet(); for( Map.Entry<String,String> me: m.entrySet() ) { soc( "Key---" +me.getKey()+" Value---"+me.getValue()); } } public static void soc(Object obj) { System.out.println(obj); } } /* 以上代码编译运行结果: 233 233 233 233 [hjk, yhdn, vgbda, tr] hjk yhdn vgbda tr [hjk, yhdn, vgbda, tr] Key---yu01 Value---李四 Key---yu12 Value---小姐 Key---yu45 Value---红的 Key---yu3 Value---大炮 */
——————分割线——————
/* jdk1.5版本出现的新特性: 可变参数 */ import java.util.*; class Je7 { public static void main(String[] args) { kk(12,45,75,62); //隐形的把这些数字封装成数组 //kk2(455,58,"hjn");//这句话编译错误 /* 为什么第二句的kk2(455,58,"hjn");编译时候会出错呢? 因为使用可变参数的时候,已经自动把括号里面的数字包装成数组了, 后面的"hjn"则是不能够被装进int型的数组里面。 */ kk3("hjk",56,84,24); //这句话编译运行成功的,表明可变参数要定义在括号的最后面 } public static void kk(int... a) //当然这里不仅仅只可以写int,也可以是其他类型例如String等等或者是自己定义的类型 { System.out.println(a.length); } /* public static void kk2(int... a,String)//这句话编译出错 { System.out.println(a.length); } */ public static void kk3(String a,int... b) { System.out.println(b.length); } }
————————分割线——————
/* 静态导入 */ import java.util.*; import static java.util.Arrays.*;//导入Arrays类中所有的静态成员 import static java.lang.System.*;//导入System类中所有静态成员 class Je8 { public static void main(String[] args) { int[] x={12,65,75,48}; //Arrays.sort(x); sort(x);//把数组排序 /* 因为之前导入Arrays类中所有的静态成员, 所以Arrays.sort(x);的Arrays可以省略。 */ soc(Arrays.toString(x)); /* soc(toString(x));//这句话编译不通过 虽然前面导入了Arrays类里面的静态成员都导入了, 但是toString()这个方法在Object类里面也有, 所有的类都是直接或者间接继承Object类, 对于这种不同包里面有同名方法, 如果不明确写出哪一个包或者哪一个类的方法, 编译会出错。 */ System.out.println("HelloWorld!"); out.println("huhu"); } public static void soc(Object obj) { System.out.println(obj); } }
版权声明:本文为博主原创文章,未经博主允许不得转载。