标签：黑马程序员
------<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---[[I@659e0bfd]
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);
}
}
版权声明：本文为博主原创文章，未经博主允许不得转载。
黑马程序员——19，Collections工具类，Arrays工具类，高级for循环，可变参数，静态导入
标签：黑马程序员
原文地址：http://blog.csdn.net/dangaodeaiyi/article/details/47337489
