黑马程序猿——19，Collections工具类，Arrays工具类，高级for循环，可变參数，静态导入
------<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);
}
}