黑马程序员——Collections、Arrays、其他对象

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
Collections

首先了解Collections和Collection的区别：

Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。

它有两个常用的子接口：

List：对元素都有定义索引。有序的。可以重复元素。

Set：不可以重复元素。无序

而Collections是集合框架中的一个工具类。该类中的方法都是静态的。提供的方法中有可以对list集合进行排序，二分查找等方法

通常常用的集合都是线程不安全的。因为要提高效率。如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。

常用方法：

对List排序：

public static <T extendsComparable<? super T>> void sort(List<T> list);

public static <T> voidsort(List<T> list,Comparator<? super T> c);

获取最值：

public static <T extendsObject & Comparable<? extends T>> T max(Collection<? extendsT> coll);

public static <T> Tmax(Collection<? extends T> coll,Comparator<> extends T> comp);

二分查找：

public static <T> intbinarySearch(List<? extends Comparable<? super T>> list,T key);

public static <T> intbinarySearch(List<? extends T> list,T key,Comparator<? super T> c);

如果没有找到返回-1

替换反转：

public static <T> voidfill(List<? super T> list,T obj);fill方法可以将List集合中所有元素替换成指定元素。

public static <T>boolean replaceAll(List<T> list,T oldVal,T newVal);

public static voidreverse(List<?> list);

public static <T>Comparator<T> reverseOrder();

public static <T>Comparator<T> reverseOrder(Comparator<T> cmp);

public static voidswap(List<?> list,int i,int j);

public static voidshuffle(List<?> list);

Collections的示例：

import java.util.*;
class CollectionsDemo2
{
public static void main(String[] args)
{
//fillDemo();
replaceAllDemo();
}

public static void replaceAllDemo()
{
List<String> list = new ArrayList<String>();

list.add("asdf");
list.add("tghh");
list.add("sfty");
list.add("bb");

sop(list);
Collections.replaceAll(list,"bb","yy");
sop(list);
Collections.reverse(list);
sop(list);
}

/*
fill方法可以将list集合中所有元素替换成指定元素，

*/

public static void fillDemo()
{
List<String> list = new ArrayList<String>();

list.add("asdf");
list.add("tghh");
list.add("sfty");
list.add("bb");
list.add("aliu");
list.add("loyn");

sop(list);
Collections.fill(list,"pp");
sop(list);
}

public static void sop(Object obj)
{
System.out.println(obj);
}
}

运行结果：



Arrays

是一个用于操作数组的工具类，里面方法也全是静态的，不需要创建对象

数组变集合：

用的是Arrays中的asList()方法

例如：List<String>list = Arrays.asList(arr);

好处：可以使用集合的思想和方法来操作数组中的元素。

注意：将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的

如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。

例如：

String[ ] arr = {“aaa”,"bc","ddd"};

List<String> li = Arrays.asList(arr );

如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

例如：

int[ ] nums = {2,3,4};

List<int[ ]> li = Arrays.asList(nums);

集合变数组：

Collection接口中的toArray()方法

指定类型的数组到底要定义多长呢？

当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组，长度为集合的size。

当指定类型的数组长度大于了集合的size，就不会创建新的数组，而是使用传递进来的数组，所以创建一个刚刚好的数组最优。使用.size()方法即可。

为什么要集合变数组？

为了限定对元素的操作，不需要进行增删了。

示例：

import java.util.*;

public class ToArray{
public static void main(String[] args){
List<String> list = new ArrayList<String>();
list.add( "abc1");
list.add( "abc2");
list.add( "abc3");

String[] arr = list.toArray( new String[2]);

System.out.println(Arrays.toString(arr));
}
}

运行结果：



增强for循环

格式：

for（数据类型 变量名：被遍历的集合（Collection）或者数组）{ }

局限：只能取出，不能修改。对集合进行遍历，只能获取集合元素，但是不能对集合进行操作。

而迭代器除了遍历，还可以进行remove集合中元素的动作，如果是用ListIterator，还可以在遍历过程中进行增删改查的动作。

传统for循环与增强for循环有什么区别？

高级for循环有一个局限性，必须有被遍历的目标，建议在遍历数组的时候，还是使用传统for循环语句。

可变参数

格式：

public static void show(String str,int… arr)

其实就是上一种数组参数的简写形式，不用每一次都手动建立数组对象，只要将要操作的元素作为参数传递即可，隐式将这些参数封装成了数组。

例如：

show（2,3,5,6,7）

public static void show(int… arr)

使用时注意：可变参数一定要定义在参数列表的最后面。

静态导入

import static java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。

import static java.lang.System.*;//导入了System类中所有静态成员。

当类名重名时，需要指定具体的包名。

当方法重名时，要指定具体所属的对象或者类。

示例：

import static java.util.Arrays.*;
import static java.lang.System.*;
import java.util.*;

class  StaticImport extends Object
{
public static void main(String[] args)
{

out.println("haha");//可以直接省略书写System.
int[] arr = {3,1,5};

sort(arr);//使用Arrays工具类的方法sort时就可以省略书写Arrays.

int index = binarySearch(arr,1);
out.println("Index="+index);

//当没有指定继承时，所以类默认继承了Object，
//因为toString方法都具备，所以为了区分，必须写上具体调用者
out.println(Arrays.toString(arr));
}
}

其他对象

System类

System：类中的方法和属性都是静态的

out：标准输出，默认是控制台（屏幕）

in：标准输入。默认是键盘。

获取系统属性信息：Properties getProperties()

因为Properties是hashtable的子类，也就是Map集合的一个子类对象。那么可以通过map的方法取出该集合中的元素。

该集合中存储的都是字符串，没有泛型定义。

在系统内定义特有信息：

String setProperty(Stringkey,String value);

Runtime类

该类并没有提供构造函数，说明不可以new对象，

那么会直接想到该类中的方法都是静态的，

发现该类中还有非静态方法，说明该类肯定会提供方法获取本类对象。

而且该方法是静态的，并返回值类型是本类类型。

有这个特点可以看出该类使用了单例设计模式完成。

方法：

1，获取本类对象

static RuntimegetRuntime();

2，在单独的进程中执行指定字符串命令

Processexec(String command);

3，在Process中有一个杀掉子进程的方法，可将exec方法开启的进程结束

void destroy();

date类

java中的默认显示格式为：Mon Jun 10 22:35:21 CST2013

默认的格式不一定满足每个人的需求，那么就需要自定义格式化模式。因为Date类中的大部分方法已过时，所以只能找其子类来实现。

子类DateFormat中有format方法可以实现，但是DateFormat是抽象类，不能实例化。但是DateFormat下SimpleDateFormat子类，可以定义时间模式。

步骤：

1，创建Date对象

2，将时间模式封装到SimpleDateFormat对象中

3，调用format方法让格式化模式指定Date对象

示例：

import java.util.*;
import java.text.*;
class DateDemo
{
public static void main(String[] args)
{
Date d=new Date();
System.out.println(d);//打印的时间看不懂，希望有些格式
//将模式封装到SimpleDateformat对象中。
SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日E HH:mm:ss");
//调用format方法让模式格式化指定Date对象。
String time=sdf.format(d);
System.out.println("time="+time);
}

}

运行结果：



Carendar类

Calendar是一个抽象类，Calendar可以对年月日等时间进行获取。

基本方法：

获取年份：Calendar.YEAR

获取月份：Calendar.MONTH

获取日期：Calendar.DAY_OF_MONTH

获取星期：Calendar.DAY_OF_WEEK

获取小时：Calendar.HOUR_OF_DAY

获取分钟：Calendar.MINUTE

获取秒数：Calendar.SECOND

设置日历字段 YEAR、MONTH和DAY_OF_MONTH的值：void set(int year,int month,int date);

根据日历的规则，为给定的日历字段添加或减去指定的时间量：void add(int field,int amount);

获取指定的日历字段对应的时间值：int get(int field);

将给定日历字段对应的时间值设置为给定值：void set(int field,int value);

例如：

c.set(2012,2,23);

c.add(Carendar.YEAR,4);

Math类

Math类中的方法：

ceil ：ceil返回大于指定数据的最小整数。

示例：double d = Math.ceil(12.34);//返回13.0

floor：返回小于指定数据的最大整数。

示例：double d1 =Math.floor(12.34);//返回12.0

round：四舍五入

示例：long l = Math.round(12.34);//返回12

pow：double d2 = Math.pow(2,3);//2的3次方返回8

random：随机数

double d = Math.random()//[0,1)包括0，不包括1的随机小数。

int d = (int)(Math.random()*10+1);//1到10之间的随机整数。

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------