1、集合框架的工具类：
|--Collections:是一个类、collection是一个接口。
特点：1、方法全部是静态的、不需要创建对象、类名直接调用。
2、能把非同步的变成同步，也就是说把不安全的变成安全的。
常用方法:
binarySearch（）：只能对list集合进行查找，为什么？因为查找的时候有角标，保证元素有顺序，返回的是：-（插入点）-1；-1是为了出现0的情况。
Max（）：求最值：
Public static <T extends Object&& Comparator<? Super T>> T getMax(Collection<? Extends T>){
Iterator<? Extends T> it=coll.iterator():
T max=it.next():
While(it.hasNext()){
T temp=it.next();
If(temp.compareTo(amx))
Max=temp;
}
Return max;
}
reverseOder():从大到小反序。
Fill():全部替换为自己指定的。
Shuffle():随机置换，比如书扑克牌
halfSearch():折半查找
synchronizedList():能解决线程不安全，并保证一定的高效，将非同步的集合转成同步集合。
|--collection和collections的区别：这个很重点哦！！！
1、collections是集合框架中的一个工具类，里面提供了操作较多的对集合进行操作的方法，比如说synchronizedList、binarySeach()等。它还可以把非同的的变成同步的，也就说把不安全的变成安全的。
2、Collection同样是集合框架中的一个工具类，单列集合、顶层接口、定义了单列集合的顶层方法、增删改查，有两个子接口list、set，这样两个子接口下面各有两个常用的子类：list有arrayList、linkedlist，set有hashSet、treeSet。（自己还可以扩展、越多越好）
2、Arrays:
由于数组中只有一个属性可以使用length:为了方便数组对象的使用，所以出现了arrays。
|--常见方法：
binarySearch():二分查找，重载的形式，使用该方法之前必须对数组进行排序，所以说只能对有序的数组进行使用，工具类一般是不用创建对象的，直接用类名调用就可以了。
copyOf():赋值数组中的一部分。
Equals（）：对数组对象进行判断，是否相同。
deepEquals（）：深度判断，当有两个数组里面还有数组时除了判断数组里面的元素，还要判断数组里面的数组
Fill():把数组中的元素全部替换成指定的值。
hashCode():算出数组的hash码。
Sort（）：排序，可以对对象进行排序。还可以对泛型进行排序。
toString（）：返回字符串。
举个小例子
Int[] arr={3,4,2,8}:
Sop(Arrays.toString(arr));//[3,4,2,8]
3、增强特性：
|--asList（）：能将数组变成集合：
Eg:String[] arr={"ahas","abd","haha","xixi"};
List list=Arrays.aslist(arr);
返回一个list集合，将数组中的元素直接作为list集合的元素存在，
好处：将数组转成集合后，就可以使用集合的方法来操作数组中的元素了，因为数组只有一个属性length，而且arrays中也没有足够的多的方法去操作集合。比如说查询数组中是否包含哪个元素。
Eg:sop(list.contains("abd"));true
sop(list.indexOf("abd"));//index=1;查找它的位置。
List.add("heihei")://不支持操作异常，因为数组长度是固定的，这里尽管改造成了集合，但是还使用低层的数组，不能做改变数组长度的操作，也就说增删不能操作。
如果数组中存储的都是对象，转成集合时，会将数组中的元素作为集合中的元素存在，如果数组中的存储的都是基本数据类型转成集合时，该数组会作为集合中的元素存在。
|--toArray:将集合编程数组：
Eg:collection<String>coll=new Collection<String>()
Coll.add("abc");
oll.add("nba");
oll.add("xixi");
String arr=coll.toArray(new String[2]);
Sop(Array.toString(arr)):[abc.nba,xixi]
1、这里面有一个小问题就是
为什么能装四个？但是数组的长度只定义的是2个
原因：给toArray传递指定类型的数组时，长度该如何指定呢？如果长度指定值比集合中的size小，那么toArray方法内部会创建一个该类型的数组，长度和集合长度一致。用于将集合中的元素存储得到数组中，如果场地指定值比集合size大，那么toArray方法内部不会创建新数组，以传递的数组为主，超出集合的长度的部分元素默认为null.所以建议传递的数组和集合size相等。使用coll.size():
2、为什么要将集合变成数组？
其实是为了限定对元素的操作方法，尤其是增删。
|--foreach：增强for循环。
Eg：ArrayList<String>a=new ArrayList<String>():
A.add("abc1");
A.add("abc2");
A.add("abc3");
For(Iterator<String>it=a.iterator();it.,hasNext()){
Sop(it.,next());
}
这是最常用的迭代器方式：
增强for循环：
For(数据类型 变量名：数组或者collection集合){}
For(String str:a){
Sop(str):
}
面试题：
1、传统for循环和增强for循环的区别？
传统for循环可以通过增量完成循环的动作，让指定代码运行多次，增强for循环遍历必须有目标，而且目标只能是数组和collection单列集合。
2、增强for循环和迭代器的区别？
通常增强for循环只用于遍历目标，遍历过程中少有对元素的操作，而迭代器在遍历元素的过程中，可以对遍历的元素进行操作。比如remove。
3、代码实现：
Map<Integer,String>map=new Map<Integet,String>();
Map.put(2,"haha");
Map.put(2,"qq");
Map.put(3,"jjha");
For(Integer key:map.keySet){
String value=map.getKey();
Sop(key+value);
}
第二种方式：
For(Map.entry<Integer,String>me:entrySet()){
Integer key=me.getKey():
String value=me.getValue():
Sop(value+key);
}
|--可变参数：
好处：不用显示的创建数组，只要将数组中的元素作为参数进行传递即可，nebulizer会自动将这些元素封装到一个数组中，并进行传递，其实该特性的好处就是简化书写，减少了数组的定义。
弊端：
1、不要以为可以将所有的数组参数变成可变参数。
2、可变参数只能定义在参数列表的结尾。
Eg:public static void int add(int a,int b,int...nums)如果放在前面就是语法错误。
实现代码：
例子是:多个数相加：
思路：数据多了存储起来，用数组存起来
Public static void add(int[] arr){
Int sum=0;
For(int x=0;x<arr.length;x++)
Sum+=arr[x];
}
Return sum;
//更为简单的方法，可变参数，其实就是一个数组。
Public static int add(int...nums)
Return 2;
|--System类：
特点：
1、该类中的方法都是静态的，不可以被实例化。
2、该类可以获取JVM启动时从本地系统取到的属性信息，通过一个getProperites方法就可以获取所有的系统的信息，而且信息都是键值对的形式体现，而且键都是固定的，通过查阅这个方法的api文档说明，就可以知道键的名称，所以要获取指定的系统平台中的信息，要通过该类来完成。
3、它有两个属性很重要：
一个是out属性，对应的是标准的输出设备：显示器，软件：控制台
一个in 属性：对应的标准的输入设备：键盘，所以获取键盘录入信息就要使用该属性。
4、获取系统当前的时间：
Long currentTimeMillis();
5、实现代码：
1、currentTimeMillis();获取当前时间。
public static void main(String[]args){
long time=System.curentTimeMillis();
sop(time);打印当前时间的毫秒值。
}
2、getProperties():获取当前系统的属性集。
它是map集合的一个子类：Hashtable
它的返回值是没有泛型，因为它里面都是固定好的字符。
eg：
Properties prop=System.getProperties();
Set<String> namesSet=prop.stringProperties():
for(String name:namesSet){
String value=prop.getProperty(name);
sop(name+value);
}
获取本地的信息；
有什么用处
eg:
Properties prop=System.getProperties();
String value=System.getProperty("os.name");
if(value.equalsIgnoreCase("windows xp")){
sop("该软件可以安装");
}else{
sop("该系统不可以安装");
}
比如说在不同的操作系统上换行
String line=System.getProperty("line.separator");
System.out.println("hello"+line+"world");
这里不管是在windows中还是UNIX还是Linux中都是换行。
|--Runtime类：
特点：
1、它代表的是一个运行时实例
2、它并不能创建对象，因为没有构造函数
3、它居然有非静态的方法，说明该类中必须有静态方法，而且返回值类型都是Runtime类型
4、它只有一个静态方法返回了本类对象，getRuntime说明该类使用了单列集合。
5、实现代码：
问题：哪里见过单列设计？java当中本身就有单列设计的体现，Runtime对象。
eg:Runtime r=Runtime.getRuntime();
process p= r.exec("notepad");//打开记事本
p.destroy();//杀死子线程 java中只能杀它开启的， 不是它开启的杀不了。
它不仅能打开某个应用程序，还可以用这个程序打开它关联的文件
Process p=r.exec("kankan.exe E:\\java0218\\xxx.avi");
|--math类：
该类中定义了操作数学运算的方法，都是静态的。
Ceil();返回大于参数的最小整数。
Floor():返回小于参数的最大整数
Round();四舍五入
实现代码：
Pow();幂运算
Random();获取伪随机数。
eg:double d=12.45;
double d1=math.ceil(d);//大于指定参数的最小整数
double d2=math.floor(d);//小于指定参数最大整数
double d3=math.round(d);//四舍五入。，
pow():幂次方运算。
eg：double d4=math.pow(10,2);//10的二次方。
random():返回带正好的double值，该值大于等于0.0且小于1.0返回值是随机数。
伪随机的数：
eg:for(int x=0;x<10;x++){
double d=math.random();
要包含1到10的随机数
int d=(int)(math.random()*10+1);
System.out.println(d);
}
应用：彩票、洗牌等等。
|--Random类：
Int nextInt(int):获取随机数。
eg:int d=nextInt(6)+1;骰子模拟；
|--静态导入：
staticImport
List<String>list=new ArrayList<String>();
list.add("abc3");
list.add("abc1");
list.add("abc2");
sop(list);
Collections.sort(list);
String max=Collections.max(list);
sop(amx);
上面使用Collections的方法，都必须用这个名称
那么是否有简化的方式呢？
import static java.util.Collections.sort;导入了Collections类中的静态方法。
所以只用导入Collections的方法就可以了。
import static java.util.Collections.*;
5.0出现的新特性。
只能导入静态成员，也就是共享的。
5.0出现的新特性：静态导入、增强for、可变参数、自动拆装箱、StringBuilder
------- android培训、 java培训、期待与您交流！ ----------
825
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
