黑马程序员---集合框架

-------http://www.itheima.comjava培训、android培训期待与您交流！-------

一、集合框架概述
数组：固定长度
Collection:集合类，用于存储对象，相当于一个容器，长度可变。
List(有序，可重复，有索引)
　　 ArrayList(数组结构、查询速度快，增删稍慢、线程不同步)
     LinkedList(链表结构、增删速度快，查询慢、)
     Vector(数组结构，线程同步)
Set(无序，不可重复)
     HashSet(数据结构哈希表、非同步)
     TreeSet(二叉树)
Map (映射，键值对)
　　  HashMap(哈希表，允许使用null键和null值，线程不同步  效率高)
　　  HashTable(哈希表，不可存入null建和null值，线程同步，  效率低)
　　  TreeMap(二叉树，线程不同步，可用于给map集合中的键  进行排序)

二、集合(Collection)的共性方法：
(1)创建集合容器(Collection接口的子类)：
     ArrayList al = new ArrayList();
     public static void sop(Object obj) {
System.out.println(obj);
}
(2)添加元素：al.add("java01");
(3)获取元素个数(集合长度)： sop(al.size());
(4)打印原集合：sop(al);
(5)删除集合：al.remove("java05");
(6)判断：sop("判断java03是否存在？"+al.contains("java03"));
  sop("判断集合是否为空？"+al.isEmpty());
(7)取交集 al中打印的是al和al2相同的元素
                ArrayList al2 = new ArrayList();
　            　al2.add("java01");
al2.add("java02");
al.retainAll(al2);
//去除al2中与al相同的元素
al.removeAll(al2);

(8)迭代器：取出集合中元素的操作方式。
           

    ArrayList al = new ArrayList();
		al.add("java01");
		al.add("java02");
		//集合对象调用iterator方法，返回Iterator接口。  接口型引用指向子类对象，通过集合中的iterator方法获得
		Iterator it = al.iterator();
		while(it.hasNext()){
			sop(it.next());
		}
		//当取出集合中的元素后，Iterator对象就会自动消失(垃圾回收机制)，节约内存空间
		for (Iterator it = al.iterator();it.hasNext();)	{
			sop(it.next());
		}

三、List集合

1、List中的特有方法(凡是带有角标操作的方法)
add(int index, E element)remove(int index)
set(int index, E element)
get(int index)
subList(int fromIndex, int toIndex)

listIterator()：List集合特有的迭代器，是Iterator的子接口。
作用：实现在遍历集合中元素时对元素进行增删改查的操作。
　　

ListIterator li = al.listIterator();
		//此时列表未遍历，指针还在最初位置(0角标)
		sop(li.hasPrevious());//false
		while(li.hasNext()){
			//由于不知道集合中的元素是什么类型，故用上帝(object)标识li中的某个元素
			Object obj = li.next();
			if (obj.equals("java02"))	{
				li.set("java009");
			}
		}
		//元素遍历完，指针处于角标4的后面，故没有下一个元素
		sop(li.hasNext());//false  正向遍历
		//元素遍历完，指针处于角标4的后面，故前一个有元素
		sop(li.hasPrevious());//true  逆向遍历

2、List集合具体对象特点
(1)LinkedList的特有方法
　

　LinkedList link = new LinkedList();
　　link.addFirst("java01");
　　link.addLast("java01");
　　//获取元素，但并不删除元素
　　		//sop(link.getFirst());
　　		sop(link.getLast());
　　		sop(link.size());
　　//获取集合中的所有元素
　　		while(!link.isEmpty())
　　		{
　　			sop(link.removeFirst());
　　		}

LinkedList的运用：
模拟一个队列或堆栈数据结构
堆栈：先进后出
队列：先进先出

import java.util.*;
class DuiLie{
	//对队列的操作时基于链表结构的，所以首先声明
	private LinkedList link;
	DuiLie(){
		 link = new LinkedList();		
	}
	//构造自定义方法，用于添加元素
	public void myAdd(Object obj){
		link.addLast(obj);
	}
	public Object myGet(){
		return link.removeFirst();
	}
	public boolean isNull(){
		return link.isEmpty();
	}
}
class LinkedListTest {
	public static void main(String[] args) {
		DuiLie dl = new DuiLie();
		dl.myAdd("java01");
		dl.myAdd("java02");
		dl.myAdd("java03");
		dl.myAdd("java04");	
		while (!dl.isNull()){
			System.out.println(dl.myGet());
		}	
	}
}

(2)Vector
枚举是Vector集合特有的取出方式。

import java.util.*;
class VectorDemo{
	public static void main(String[] args) 	{
		Vector v = new Vector();
		v.add("java01");
		v.add("java02");	
		//通过枚举中呃方法获取集合中的元素
		Enumeration en = v.elements();
		while(en.hasMoreElements())	{
			System.out.println(en.nextElement());
		}
	}
}

(3)ArrayList
　　将自定义对象作为元素存储到ArrayList集合中，并去除重复元素。姓名相同，年龄相同视为同一个人。
　　需要定义一个新的集合用于去除相同的元素。当老集合中的元素存到新集合中时，新集合中的元素要与该集合中的其他元素进行比较，如果有相同元素，则舍弃，否则存入。
    ArrayList集合添加元素时，默认的是存储的Object类型的数据，在这里，要存储的是Person类型的对象，即父类引用指向了子类对象(多态)，所以，要强制将Person向下转型：Person p = (Person)obj;   在定义Person类时，默认继承的是Object类，所以子类Person继承了父类的所有方法，equals则是其中一个，其作用是比较地址值。当ArrayList判断元素是否相等时，调用的就是该方法，而新建对象指向的都是同一个地址值，故不能将重复元素去除。所以，要在Person类中复写equals方法，定义自己所需要的比较方法，用于比较对象中的具体内容是否相等。
思路：
1、定义Person类，将属性和方法封装到该类中，
2、定义一个新容器，用于存储从老集合取出的元素，
3、将Person对象取出,

import java.util.*;
class  ArrayListTest2{
	public static void sop(Object obj)	{
		System.out.println(obj);
	}
	public static void main(String[] args) 	{
		ArrayList al = new ArrayList();
        //al.add(Object obj);-->Object obj = new Person("lisi01",21);
		al.add(new Person("lisi01",21)); 
		al.add(new Person("lisi02",23));
		al.add(new Person("lisi02",23));
		al.add(new Person("lisi03",24));
		al.add(new Person("lisi04",29));
		al.add(new Person("lisi04",29));
		//并未将重复元素去除
		al = singleElement(al);
		//若不复写equals方法，则元素不能删除,底层调用的也是equals方法
		//sop("remove 03 "+al.remove(new Person("lisi04",29)));
		Iterator it = al.iterator();
		while (it.hasNext())	{
			//Object obj = it.next();
			//Person p = (Person)obj;
			Person p = (Person)it.next();
			sop(p.getName()+"---"+p.getAge());
			//找不到符号  Person
			//lisi   zhangsan的年龄23  it.next()方法只能调用一次，否则抛出异常
			//sop(it.next().getName()+"-----"+it.next().getAge());
		}		
	}
    //定义一个方法，用于去除重复元素
	public static ArrayList singleElement(ArrayList al){
		//新建一个容器，用于接收老集合传过来的元素
		ArrayList newal = new ArrayList();
		//遍历老集合
		Iterator it = al.iterator();
		while (it.hasNext()){
			//将老集合中遍历到的元素，用obj记录一下
			Object obj = it.next();
			//contains底层调用equals方法
			if (!(newal.contains(obj)))
				//如果新集合中不包含老集合传过来的元素，
				//将该元素添加到新集合中
				newal.add(obj);				
		}
		//否则，将新集合返回
		return newal;	
	}
}
class Person   //extends Object 调用的是Object的equals方法，比较地址值
{
	private String name;
	private int age;
	//一初始化就有姓名和年龄
	Person(String name,int age){
		this.name = name;
		this.age = age;
	}
//复写Object中的equals方法
	public boolean equals(Object obj)//底层自动调用equals方法{
		if (!(obj instanceof Person))
			return false;
		Person p = (Person)obj;
		System.out.println(this.name+"----"+p.name);
		//字符串的equals方法
		return this.name.equals(p.name) && this.age == p.age;	
	}
	public String getName(){
		return name;
	}
	public int getAge(){
		return age;
	}
}

在实际开发中，只要将声明的属性直接通过getter和setter生成即可。

四、Set集合
1、HashSet
无序的，即存入和取出的顺序不一定一致。HashSet的功能和Collection功能一致。
哈希表结构：
class Demo{
public int hashCode(){
return 60;
}
}
主函数：
　           Demo d1 = new Demo();
Demo d2 = new Demo();
System.out.println(d1);
System.out.println(d2);
打印结果为：Demo@15093f1、Demo@120bf2c这就是哈希值。
其实，JVM调用的是Demo类中的toString()方法,而该方法中就有hashCode()方法
那么我们可以覆盖父类中的hashCode()方法。再次运行，结果为：Demo@3c  Demo@3c两个对象的地址值相同，在内存中如何存储呢？当哈希值相同时，再比较是否是同一个对象(内容是否相同)，若是，则在内存中将两个对象顺沿着存储
HashSet hs = new HashSet();
//add方法返回的是boolean类型，java01存入HashSet集合
System.out.println(hs.add("java01"));
//当再次存入一个相同(哈希值和内容都一样)的元素时，不再存入
System.out.println(hs.add("java01"));
hs.add("java02");
hs.add("java03");
hs.add("java03");
hs.add("java04");
set集合的取出方式只有一种：迭代器，且set集合是无序的，按地址值取出
Iterator it = hs.iterator();
while (it.hasNext()){
System.out.println(it.next());
}

存储自定义对象：向HashSet集合中存储Person对象。
HashSet保证元素唯一性是通过元素的hashCode()和equals()方法来完成。如果元素的hashCode值相同，则再判断equals方法是否为真；
如果hashCode值不同，则不用调用equals方法。
复写父类hashCode()方法：

public int hashCode(){
		System.out.println(this.name+"--hashCode--");
		//return 60;
		//先计算哈希值，若哈希值相同，则再比较对象(内容)
		//尽量保证哈希值的唯一性，所以 * 49
		return name.hashCode()+age * 49 ;
	}
//复写父类的equals方法
	public boolean equals(Object obj)	{	
		if (!(obj instanceof Person))
				return false;
				Person p = (Person)obj;
		System.out.println(this.name+"--equals--"+p.name);
		return this.name.equals(p.name) && this.age == p.age;  }	
	}

HashSet判断和删除的依据也是根据hashCode()和equals()方法。
System.out.print(hs.contains(new Person("lisi01",21)));

2、TreeSet：
可以对set集合中的元素进行排序(自然顺序)。
排序方式一：实现Comparable接口，覆盖compareTo方法。
练习：往TreeSet集合中存储自定义对象，将学生对象存进集合中，并按年龄排序。
当直接将学生对象向TreeSet集合中存储时，会出现类型转换异常，不能把Student转换成java.lang.Object包中的Comparable。通过查看文档可以知道，Comparable接口强行对实现它的每个类的对象进行整体排序。也就是说，要让Student类实现Comparable接口，并复写Comparable接口中的compareTo()方法，才能使Student的对象具有比较性，故才可以将学生对象按年龄顺序存储进TreeSet集合。
排序时，如果只要条件相同时，再判断次要条件。

import java.util.*;
class TreeSetDemo {
	public static void main(String[] args) {	
		TreeSet ts = new TreeSet();
		ts.add(new Student("lisi03",20));
		ts.add(new Student("lisi06",23));
		ts.add(new Student("lisi007",19));
		ts.add(new Student("lisi08",18));
		Iterator it = ts.iterator();
		while (it.hasNext()){
			Student stu = (Student)it.next();
			System.out.println( stu.getName()+"---"+stu,getAge());
		}
	}
}
//存的对象要有比较性，该接口强制让学生具备比较性
class Student implements Comparable {
	private String name;
	private int age;
	Student(String name,int age){
		this.name = name;
		this.age = age;	
	}
	//覆盖Comparable中的方法
	public int compareTo(Object obj){
		//若不是学生对象
		if (!(obj instanceof Student))
				throw new RuntimeException("不是学生对象");
		//类型转换(强转)
			Student s = (Student)obj;
		//调用自身的comparaTo方法
		System.out.println(this.name+"----"+s.name);
		if (this.age > s.age)
			return 1;
		//当主要条件不符合时，再判断次要条件
		if (this.age == s.age){
			return this.name.compareTo(s.name);	
		}
	}
	public String  getName(){
		return name;	
	}
	public int  getAge(){
		return age;
	}
}

排序方式二：
定义类实现Comparator接口，覆盖compare方法，将比较器对象作为参数传递给TreeSet集合的构造函数。   元素不具备比较性，或具备的比较性不是所需要的，则让集合具备比较性，且集合初始化时就具备比较性。
按字符串的长度进行排序。

import java.util.*;
class TreeSetTest {
	public static void main(String[] args) 	{
		TreeSet ts = new TreeSet(new Compare());
		ts.add("sjgh");
		ts.add("hgiey");
		ts.add("s");
		ts.add("jgh");
		ts.add("tgh");
	
		Iterator it = ts.iterator();
		while (it.hasNext()){
			System.out.println(it.next());
		}
	}
}
//实现比较器接口
class Compare implements Comparator{
	//覆盖compare方法
	public int compare(Object o1,Object o2){
		//强制类型转换
		String s1 = (String)o1;
		String s2 = (String)o2;
		/*
		if (s1.length()>s2.length())
			return 1;
		if (s1.length() ==s2.length())
			return 0;
		return -1;
		*/
		//int num = new Integer(s1.length()).compareTo(s2.length());  可以
		//不能将相同长度的字符串存入
		int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
		//比较集合的自然顺序
		if (num == 0)
			return s1.compareTo(s2);
		return num;
	}
}

当字符串的长度相同时，再按自然顺序存储。


五、Map集合
1、概述
Map是具有映射关系的集合，通常以键值对的形式出现。
将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射一个值。
2、Map共性方法
添加：put(K key, V value)、putAll(Map<? extends K,? extends V> m)
删除：clear()、remove(Object key)
判断：containsKey(Object key)、containsValue(Object value)、isEmpty()
获取：size()、values()、keySet()、entrySet()
3、keySet、entrySet
Map<K.V>,表示一种映射关系。从字面上理解，map是映射的意思。K：该映射键的类型，V：映射值的类型
通常映射关系是成对出现的（键值对），也就是说，一个键只能对应一个值。
Map集合取出元素的原理：将Map集合转化成Set集合（因为Set集合有迭代器），再用迭代器取出元素。
Map集合的取出操作：keySet()根据取出的键获取对应的键值
                    entrySet()方法取出的是映射关系，再通过Map.Entry中的getKey和getValue()方法取出键和值
下面写个例子吧：
（1）keySet法：(1)将Map集合中的所有键存入Set集合(Set集合具有迭代器)，
                     (2)以迭代器方式取出所有键
                     (3)再根据Map集合的get方法获取每一个键对应的值

import java.util.*;
class KeySet
{
    public static void main(String[] args)
    {
        Map<String,String> map = new HashMap<String,String>();
        //向Map集合中添加元素
        map.put("01","lisi01");
        map.put("02","lisi02");
        map.put("06","lisi06");
        map.put("03","lisi03");

        //将map集合中的元素存入Set集合
        Set<String> keySet = map.keySet();

        //使用迭代器将Set集合中的元素取出
        Iterator<String> it = keySet.iterator();

        while (it.hasNext())
        {
            //先取出Map集合中的键
            String key = it.next();
            //通过键取出值(键值是成对存在的)
            String value = map.get(key);
            System.out.println(key+"--"+value);
        }
    }
}

（2）entrySet()方法：
     (1)将Map集合中的映射关系取出并存入Set集合(返回值类型为Set<Map.Entry<K,V>>)
     (2)使用迭代器取出Set集合中的映射关系，
     (3)再通过Map.Entry中的getKey和getValue()方法取出键和值                

import java.util.*;
class EntrySet
{
    public static void main(String[] args)
    {
        Map<String,String> map = new HashMap<String,String>();
        //向map集合中添加元素
        map.put("01","lisi01");
        map.put("02","lisi02");
        map.put("06","lisi06");
        map.put("03","lisi03");

        //将Map集合中的映射关系取出，存入Set集合
        Set<Map.Entry<String,String>> entryset =map.entrySet();

        //使用迭代器取出映射关系
        Iterator<Map.Entry<String,String>> it = entryset.iterator();

        while (it.hasNext())
        {
            //获取Map.Entry对象
            Map.Entry<String,String> me = it.next();
            //根据 Map.Entry中的方法取出键和值
            String key =me.getKey();
            String value = me.getValue();
            System.out.println(key+"---"+value);
        }
    }
}

Map.Entry是一个嵌套类，即Entry是Map接口的内部接口。
泛型(参见黑马程序员---泛型)
六、工具类(Collections、Arrays)
1、Collections：
在实际的开发应用中，如何选用合适的集合框架来存储数据呢？当然，这是根据需求而定。Collections类对List、Set的一些不同的功能结合起来，解决了两者不能同时使用的问题。
Collections类中的方法都是静态方法，因为该类中操作的都是共享数据，直接由类调用即可。
如果在存取过程中不需要保证元素的唯一性，但还要对元素进行排序，那么就使用到Collections类的sort方法。

import java.util.*;
class CollectionsDemo {
	public static void sop(Object obj){
		System.out.println(obj);	
	}
	public static void main(String[] args) {
		//sortDemo();
		//maxDemo();
		//binarySearchDemo();
		//fillDemo();
		//replaceAllDemo();
		reverseOrderDemo();
	}
	public static void sortDemo(){
		List<String> list = new ArrayList<String>();
		list.add("anjdig");
		list.add("jdfg");
		list.add("d");
		list.add("dfkgggk");
		list.add("dfj");

		sop(list);
		//接收一个list集合，用于给其排序
		//Collections.sort(list); 

		//可接收一个list集合和一个比较器，按照自定义比较方式比较
		Collections.sort(list ,new StrLenComparator()); 
		sop(list);
	}
	public static void maxDemo(){
		List<String> list = new ArrayList<String>();
		list.add("anjdig");
		list.add("jdfg");
		list.add("d");
		list.add("dfkgggk");
		list.add("dfj");
		
		Collections.sort(list);
		sop(list);
		//返回的是该对象中按照自然顺序排序后的最大顺序的那个对象
		//String max = Collections.max(list);
		//按照字符串长度排序后最长的那个对象
		String max = Collections.max(list,new StrLenComparator());
		sop("max="+max);
	}
	public static void binarySearchDemo(){
		List<String> list = new ArrayList<String>();
		list.add("anjdig");
		list.add("jdfg");
		list.add("d");
		list.add("fkgggk");
		list.add("dfj");

		sop(list);
		//根据元素查找该元素所在的索引，如果不存在，
		//则返回该元素-(插入点)-1，即"ab"应该插入角标0这个位置，那么，
		//返回的就是-(0)-1
		int index = Collections.binarySearch(list,"ab");
		sop("index="+index);	
	}
	public static void fillDemo(){
		List<String> list = new ArrayList<String>();
		list.add("anjdig");
		list.add("jdfg");
		list.add("d");
		list.add("dfkgggk");
		list.add("dfj");

		sop(list);
		//将集合中的元素全部用指定的元素oo替换
		//Collections.fill(list,"oo");
		//将集合中的dfkgggk替换为rr
		//Collections.replaceAll(list,"dfkgggk","rr");
		//将集合中的元素交换位置，头变尾，尾变头
		Collections.reverse(list);
		sop(list);
	}
	public static void reverseOrderDemo(){
		//若不接收一个Collections.reverseOrder()方法，则打印的是按照自然顺序排列的
		//若接收一个Collections.reverseOrder()方法，打印的则是元素逆转后的顺序
		//在Collections.reverseOrder()方法中也可以接收一个自定义的比较器，
		//TreeSet<String> ts = new TreeSet<String>
		//(Collections.reverseOrder(new StrLenComparator ));
		//用于按照自定义比较方式输出
		TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());
		ts.add("abc");
		ts.add("vjhi");
		ts.add("kjd");
		ts.add("skfodg");

		Iterator<String> it = ts.iterator();
		while (it.hasNext())
		{
			sop(it.next());
		}
	}
	
}
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.synchronizedList();
集合中的增删等方法都是非同步的，这样有利于提高效率，但有时会考虑到安全问题，所以要给这些方法添加同步，而这个方法就封装到了synchronizedList()方法中，只要直接调用即可(Collections类中都是静态方法)。
Collections.swap();可以将集合中2个位置上的元素置换位置
Collections.shuffle(); 随机地将集合中的所有元素置换位置。

2、Arrays

import java.util.*;
class ArraysDemo {
	public static void sop(Object obj){
		System.out.println(obj);	
	}
	public static void main(String[] args) {
		/*
		int[] arr = {1,9,8,4,8,4};
		sop(Arrays.toString(arr));
		*/
		String[] arr = {"fd","skrg","eui","sd"};
		List<String> list = Arrays.asList(arr);
		/*	
		false
		Exception in thread "main" java.lang.UnsupportedOperationException
		sop(list.contains("ij"));
		list.add("sioekf");
		如果数组中的元素都是对象，那么变成集合时，数组汇总的元素就直接转成集合中的元素

		int[] num = {};
		List<int[]> li = Arrays.asList(num);
		sop(li);

		如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在
		Integer[] num1 = {2,3,8};
		List<Integer> li = Arrays.asList(num1);
		sop(li);
		*/
		sop(list);	
	}
}

集合转数组：限定对元素的操作，不需对其进行增删操作。
当指定类型的数组长度小于了集合的size，那么该方法内部就会创建一个新的数组，
长度为集合的size
当指定类型的数组长度大于了集合的size，就不会创建数组，而是使用传递进来的数组
所以创建一个刚刚好的数组最优。

import java.util.*;
class CollectionToArray {
	public static void main(String[] args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("dgg");
		al.add("u");
		al.add("ty");
		al.add("jhkk");

          //String[] arr = al.toArray(new String[al.size()]);

		String[] arr = al.toArray(new String[8]);
		System.out.println(Arrays.toString(arr));
	}
}

七、增强for循环、可变参数、静态导入
1、高级for循环
高级for循环其实就是for循环的简写形式。并不是所有的for循环都可以简写为foreach，高级for循环只适用于集合或数组的遍历操作。
高级for循环格式：
           for(数据类型 变量名: 被遍历的集合或数组)
　　 {循环体}
在对集合或数组的操作中，集合一般的遍历方式是使用迭代器遍历，而且可以做删除操作，ListIterator在遍历时还可以进行增删改查操作，但如果用高级for循环，就不能做这些操作。
高级for循环的局限性：
只能获取集合元素，但不能对集合进行操作。

import java.util.*;
class ForEach {
	public static void main(String[] args) {
	
		ArrayList<String> al = new ArrayList<String>();
		al.add("abc09");
		al.add("abc01");
         	al.add("abc013");
		/*
		String是该集合中存储的数据类型，
		s是该数据类型的变量名：
		在遍历时，s指向的abc09这个对象，并打印输出；
		随后，s又指向abc01、abc13对象并打印输出
		所以s是变化的，当虚拟机按顺序查找集合中的元素时，s就不断地指向某个元素		
		*/
		for (String s : al ){
			System.out.println(s);
		}
		/*
		使用迭代方式获取集合中的元素
		Iterator<String> it = al.iterator();
		while (it.hasNext()){
			System.out.println(it.next());
		}
		*/
	}
}

2、可变参数

import java.util.*;
class ParamDemo {
	public static void main(String[] args) {
		/*
		int[] arr = {1,25,7};
		show(arr);
		*/
		show(1,2,4,23);	
	}
	/*
	当将方法定义为这中形式时，在主函数中调用该方法时，
	要先新建一个数组对象，才能调用方法,
	而将方法定义为这中形式，在调用该方法时，就不需要新建数组对象，直接调用方法即可

	JDK1.5新特性：方法的可变参数
	简化代码、提高效率

	在定义可变参数时，一定要把参数定义在参数列表的最后面。
	如果定义在了开始或中间，虚拟机就会自动的将该参数后面的不同类型的参数纳入该参数列表
	*/
	public static void show(int... arr){
		System.out.println(Arrays.toString(arr));
	}
	/*
	当将方法定义为这中形式时，在主函数中调用该方法时，
	要先新建一个数组对象，才能调用方法
	public static void show(int[] arr){
		System.out.println(Arrays.toString(arr));
	}
	*/
}

3、静态导入

/*
当类名重名时，需要指定具体的包名。
当方法重名时，指定具体所属的对象或者类。
*/
import java.util.*;
//导入的是Arrays这个类中的所有的静态成员
import static java.util.Arrays.*;
//导入的是System类中的所有静态成员
import static java.lang.System.*;
class StaticImport {
	public static void main(String[] args) {
		out.println("hello");
		int[] arr = {2,4,1,5};

		sort(arr);
		int index = binarySearch(arr,1);
		out.println(Arrays.toString(arr));
         	System.out.println("index="+index);	
		/*
		System.out.println("hello");
		int[] arr = {2,4,1,5};

		Arrays.sort(arr);
		int index = Arrays.binarySearch(arr,1);
		System.out.println(Arrays.toString(arr));
		System.out.println("index="+index);
		*/
	}
}

八、其他对象
1、System
System类是一个系统类，描述系统的一些信息。
public final class System{}：不能被实例化
类中的方法和属性都是静态的，
out:标准输出，默认输出在控制台
in：键盘录入

//静态导入
import static java.lang.System.*;
import java.util.*;
class SystemDemo 
{
	public static void main(String[] args) 
	{
		//获取系统的属性信息：
		Properties prop = System.getProperties();
		/*
		for (Object obj: prop.keySet())
		{
			String value = (String)prop.get(obj);
			out.println(obj+"--"+value);
		}
		*/
		//自定义系统属性信息
		System.setProperty("MYKEY","MYVALUE");

		//获取指定属性信息
		String value = System.getProperty("os.name");
		out.println("value="+value);
		/*
		在JVM启动时，动态加载一些属性信息			
			F:\java\day18>javac SystemDemo.java

			F:\java\day18>java SystemDemo
			value=Windows 7
			v==null

			F:\java\day18>java -Dhello=nihao SystemDemo
			value=Windows 7
			v==nihao
		*/
		String v = getProperty("hello");
		out.println("v=="+v);
			
	}
}

2、Runntime
Runtime对象
该类并没有提供构造函数，说明不可以new对象，
那么该类是否提供了静态方法，
查阅API，并没有静态方法，提供了非静态方法，
那么该类一定提供一个方法获取本类对象，而且该方法是静态的，并返回本类类型。
单利设计模式。
static Runtime getRuntime()
          返回与当前 Java 应用程序相关的运行时对象。

class RuntimeDemo 
{
	public static void main(String[] args)  throws Exception
	{
		Runtime r = Runtime.getRuntime();
		//执行记事本程序,并且可以打开某个指定文本文件
		Process p = r.exec("notepad.exe SystemDemo.java");
		//进程停留4秒被杀死
		Thread.sleep(4000);
		p.destroy();
	}
}

3、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方法，将模式格式化掉指定对象，返回值为一个字符串
		String time = sdf.format(d);
		System.out.println("time="+time);

	}
}

4、Calendar

import java.util.*;
import java.text.*;
class  CalendarDemo2
{
	public static void main(String[] args) 
	{
		Calendar c = Calendar.getInstance();
		//c.set(2013,5,17);
		c.add(Calendar.MONTH,-2);
		c.add(Calendar.DAY_OF_MONTH,-2);

		printCaledar(c);
	}
	public static void printCaledar(Calendar c)
	{
		String[] mons = {"一月","二月","三月","四月",
							"五月","六月","七月","八月",
							"九月","十月","十一月","十二月",
							};
		
		String[] weeks ={
							"","星期日","星期一","星期二","星期三","星期四",
							"星期五","星期六"
		
							};
		int index = c.get(Calendar.MONTH);
		int index1 = c.get(Calendar.DAY_OF_WEEK);
		sop(c.get(Calendar.YEAR)+"年");
		//sop((c.get(Calendar.MONTH)+1)+"月");加1麻烦
		sop(mons[index]);
		sop(c.get(Calendar.DAY_OF_MONTH)+"日");
		//sop("星期"+c.get(Calendar.DAY_OF_WEEK));
		sop(weeks[index1]);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

5、Math-Random

import java.util.*;
class MathDemo 
{
	public static void main(String[] args) 
	{
		Random r = new Random();
		for (int x = 0;x<10 ;x++ )
		{
			//获取1~10之间的随机数,包含1 但不包含10
			//int d3 = (int)(Math.random()*10+1);
			int d4 = r.nextInt(10)+1;
			sop(d4);
		}
		//show();
	}
	public static void show()
	{
		//返回大于指定数据的最小整数 13.0  -12
		double d = Math.ceil(-12.34);
		//返回小于指定数据的最大整数 16.0
		double d1 = Math.floor(16.87);
		//四舍五入23
		long l = Math.round(23.34);
		//底数 指数  8.0
		double d2 = Math.pow(2,3);

		sop("d="+d);
		sop("d="+d1);
		sop("d="+l);
		sop("d="+d2);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

-------http://www.itheima.comjava培训、android培训期待与您交流！-------