第八部分:Collections工具类
Collections是集合框架的工具类,里面存在能对List集合容器操作的方法,并且这些方法都是静态的。下面将对方法一一介绍:
1、static void sort(List<T> list):根据元素的自然顺序对指定列表进行升序排序。
static void sort(List<T> list:根据指定比较器产生的顺序对指定列表进行排序。
a、根据元素的自然顺序排序代码示例:
class HelloDemo {
public static void main(String[] args)
{
List<String> list = new ArrayList<String>();
list.add("avced");
list.add("av");
list.add("aved");
list.add("ed");
list.add("zz");
Collections.sort(list);//给list按照字母顺序排序,从第一个开始
System.out.println(list);
}
}
输出结果:
[av, avced, aved, ed, zz]//根据字符的ASCII值进行比较
b、根据比较器进行比较。这里需求是先按照字符串的长度进行比较,长度相同再根绝字符比较。
代码示例:
class StrLenComparator implements Comparator<String>
{
public int compare(String s1,String s2)
{
if(s1.length()>s2.length())
return 1;
if(s1.length()<s2.length())
return -1;
return s1.compareTo(s2);
}
}
//主函数
Collections.sort(list,new StrLenComparator());
System.out.println(list);
输出结果:
[av, ed, zz, aved, avced]
2、static max(Collection<? extends T> coll):返回自然顺序排序后的List容器内的最大元素。
如果需要自定义的顺序,往里传入比较器参数即可。
3、static binarySearch(List<? extends Comparable<? super T>> list, T key):使用二分搜索法搜索指定列表,以获得指定对象。
同样可以传入比较器。
P.S 如果要查找的key不存在与容器内,则返回的是-(插入点)-1
代码示例:
List<String> list = new ArrayList<String>();
list.add("avced");
list.add("av");
list.add("aved");
list.add("ed");
list.add("zz");
Collections.sort(list,new StrLenComparator());
int index1 = Collections.binarySearch(list,"zzz");//如果zzz不存在,返回插入点的负数再减一。这里是-6
System.out.println(index1);
输出结果:
[avced, av, aved, ed, zz]
-6
因为按照自然顺序排序后"zzz"应该插入的位置角标是5,按照公式则返回-5-1=-64、static <T> void fill(List list, T obj):使用指定元素obj替换列表的所有元素
5、static <T> boolean replaceAll(List list,T oldVal, T newVal):使用另一个值newVal替换列表中出现的所有某一指定值oldVal。
6、static oid reverse(List list):反转指定列表中元素的位置。
7、(重点)
static<T> Comparator<T> reverseOrder():返回一个比较器,它强行逆转实现了Comparable 接口的对象 collection 的自然顺序。
代码示例:
public static void main(String[] args)
{
TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());//将自然元素顺序强行逆转
ts.add("abcde");
ts.add("aaa");
ts.add("kkk");
ts.add("ccc");
Iterator it = ts.iterator();
while(it.hasNext())
{
System.out.print(it.next()+" ");
}
}
输出结果:
kkk ccc abcde aaa
同时也可以已经实现好的比较器进行强制转换顺序。
代码示例:
TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));
StrLenComparetor()即为新的比较器。8、static void swap(List list, int i, int j):将List容器中指定位置i和j的元素进行调换。
static void shuffle(List list):对指定列表的所有元素以随机方式进行重新排序。
第九部分:Arrays工具类
Arrays工具类是用于操作数组的工作类,里面都是静态方法。下面将介绍里面的方法。
1、重点:List asList(数组)将数组转成集合。
这个方法的好处是:可以使用集合的思想和方法来操作数组中的元素
注意:将数组变成集合,不可以使用集合的增删方法,因为数组的长度是固定的
可以使用的是:contains()、get()、indexOf(Object obj):返回obj第一次出现的位置、subList()方法。
但是如果发生增删操作了,那么会发生UnsupportedOperationException。
代码示例:
String[] arr = {"aaa","cc","dsd"};
List<String> ls = Arrays.asList(arr);
System.out.println("contains:"+ls.contains("cc"));
System.out.println(ls);
这里需要注意的是:
如果数组中的元素都是对象,那么变成集合时,数组中的元素就直接转成集合中元素;
如果数组中的元素都是基本数据类型,那么会将该数组整体作为集合中的单个元素存在。因此如果存入int[]数组时候,应该这么存:
int[] arr = {2,3,4};
List<int[]> list = Arrays.asList(arr);
或者另一种方法:
Integer[] arr = {2,4,5};
List<Integer> list = Arrays.asList(arr);
2、上面提到的数组转成集合,那么下面将介绍怎么将集合转成数组。
这里使用的方法是接口Collection的toArray()方法。
代码示例:
class
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
al.add("abc");
al.add("c");
al.add("s");
/*
1、指定类型的数组到底要定义多长?
当指定类型的数组小于了集合的size,那么该方法内部会创建一个新的数组,长度为集合的size
当指定类型的数组长度大于了集合的size,就不会新创建数组。而是使用传递进来的数组
所以创建一个刚刚好的数组最最优
2、为什么要将集合变成数组
为了限定对元素的操作。
不需要进行增删了。
*/
String[] arr = al.toArray(new String[al.size()]);
System.out.println(Arrays.toString(arr));//打印数组的元素
}
}
第十部分:其他对象类
out:标准输出,默认是控制台
in:标准输入,默认是键盘
获取系统属性信息:Properties getProperties()
方法示例:
import java.util.Properties;
import java.util.Set;
public class HelloDemo {
public static void main(String[] args) {
// 获取系统的属性信息,并存储到了Properties集合中
Properties prop = System.getProperties();
Set<String> nameSet = prop.stringPropertyNames();
for (String name : nameSet) {
String value = prop.getProperty(name);
System.out.println(name + " = " + value);
}
}
}
2、Runtime
该类中并没有提供构造函数。说明不可以new对象,会直接想到该类中的方法都是静态的。
发现该类中还有非静态方法,说明该类肯定会提供一个方法,获取本类对象。而且该方法是静态的,并且返回值类型是本类类型。
由这个特点可以看出,该类使用了单例设计模式完成。
代码示例:
class
{
public static void main(String[] args) throws Exception
{
Runtime r = Runtime.getRuntime();
//启动程序和杀掉子进程
Process p = r.exec("D:\\Program Files (x86)\\360\\360zip\\360zip.exe");
Thread.sleep(4000);
p.destroy();
}
}
3、Date和SimpleDateFormat的联合使用
代码示例
import java.text.SimpleDateFormat;
import java.util.Date;
public class HelloDemo {
public static void main(String[] args) {
Date d = new Date();
System.out.println(d);
// 打印的事件看不懂,希望有些格式
// 将模式封装到SimpleDateFormat对象中
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日E hh:mm:ss");
// 调用format方法让模式格式化指定Date对象
String time = sdf.format(d);
String time1 = sdf1.format(d);
System.out.println(time);
System.out.println(time1);
}
}
输出结果:
Wed Aug 12 19:56:59 GMT+08:00 2015
2015年08月12日
2015年08月12日星期三 07:56:59
4、Calendar 类
Calendar是一个抽象类,它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR等日历字段之间的转换提供了一些方法,并为操作日历字段(例如获得下星期的日期)提供了一些方法。
这个方法使用查表法比较好:
String[] mons = {"一月","二月","三月","四月","五月","六月","七月","八月","九月","十月","十一月","十二月"};
String[] weeks = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
获取年:
Calendar c = Calendar.getInstance();
System.out.println(c.get(Calendar.YEAR)+"年");
获取月份:
int num = c.get(Calendar.MONTH);
System.out.println(mons[num]);
获取星期:
int index = c.get(Calendar.DAY_OF_WEEK);
System.out.println(weeks[index]);
获取一个月中的天数
System.out.println(c.get(Calendar.DAY_OF_MONTH)+"日");
5、Math类
Math.ceil(double d):返回大于指定数据的最小整数
Math.floor(double d):返回小于指定数据的最大整数
Math.round(double d):四舍五入,返回long型
Math.pow(int a,int b):返回a的b次幂
小知识点,获取随机数
<span style="font-size:14px;">Random r = new Random();
int x = r.nextInt(10)+1;</span>
第十一部分:小知识点
1、增强for循环
格式:
for(数据类型 变量名: 遍历的集合(Collection)或者数组)
{}
对集合进行遍历:只能获取集合中的元素,但是不能对集合进行操作。
迭代器除了遍历,还可以进行remove集合中元素的操作
如果是用ListIterator,还可以在遍历过程中对集合元素进行增删查改
传统for循环和高级for循环有什么区别?
高级for有一个局限性,必须有被遍历的目标。
注:建议在遍历数组时候,还是使用传统for。因为传统for可以定义角标
代码示例:
class
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
al.add("abc");
al.add("c");
al.add("s");
for(String s : al)
{
System.out.println(s);
}
int[] arr = {3,5,1};
for(int i:arr)
{
。。。
}
//map不支持迭代器
HashMap<Integer,String> hm = new HashMap<Integer,String>();
hm.put(1,"a");
hm.put(2,"b");
hm.put(3,"c");
Set<Integer> keySet = hm.keySet();
for(Integer i : keySet)
{
sop(i+":"+hm.get(i));
}
HashMap<Integer,String> hm = new HashMap<Integer,String>();
hm.put(1,"a");
hm.put(2,"b");
hm.put(3,"c");
Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();
for(Map.Entry<Integer,String> me : entrySet)//for(Map.Entry<Integer,String> me : hm.entrySet())
{
sop(me.getKey()+":"+me.getValue());
}
//诀窍,set什么类型,冒号:左边就是什么类型
}
}
2、可变参数
JDK1.5以后出现的新特性
可变参数,其实就是上一种数组参数的简写形式。不用每一次都手动的建立数组对象,只要将操作的元素作为参数传递即可。
隐式将这些参数封装成了数组。
(int... arr)
方法的可变参数
使用时注意:可变参数一定要定义在参数列表的最后面
如(String str , int... arr)
代码示例:
class
{
public static void main(String[] args)
{
show(2,3);
show(2,3,4,3,7,23);
show();
}
public static void show(int... arr)
{
sop(arr.length);
}
}
3、静态导入
导入类中的所有静态成员。
使用示例:
import java.util.*;
import static java.util.Arrays.*;//导入的是Array这个类中的所有静态成员
class Demo//extends Object
{
public static void main(String[] args)
{
//导入前
int[] arr = {1,3,4};
Arrays.sort(arr);
int index = Arrays.binarySearch(arr,1);
System.out.println(Arrays.toString(arr));
System.out.println(index);
//导入以后
int[] arr = {1,3,4};
sort(arr);
int index = binarySearch(arr,1);
System.out.println(Arrays.toString(arr));//这里Arrays必须写,因为Object里也有这个方法
System.out.println(index);
}
}