(10)Java泛型-Map集合-集合框架工具类-可变参数-静态导入

--
部分1.5新特性Java泛型-Map集合-集合框架工具类

泛型

概述：
JDK1.5版本以后出现的新特性，用于解决安全问题，是一个类型安全机制。
对于泛型可以这样理解：
没有使用泛型时，只要是对象，不管是什么类型的对象，都可以存储进同一个集合中。使用泛型集合，可以将一个集合中的元素限定为一个特定类型，集合中只能存储同一个类型的对象，这样更安全；并且当从集合获取一个对象时，编译器也可以知道这个对象的类型，不需要对对象进行强制类型转换，这样更方便。
好处：
1， 将运行时期出现的问题ClassCastException。转移到编译时期。方便程序员解决问题，让运行运行时异常减少，较安全。
2， 避免了强制转换的麻烦。
泛型格式：
通过<>来定义要操作的引用数据类型。
放到返回类型的前面，修饰符的后面不然会报错
示例：ArrayList<String> al = new ArrayList<String>();
泛型类

什么是泛型类，简单的说就是带泛型的类。
在泛型出现之前，比如对于定义工具类，接收的类型不一样，比较通用的方法是采用多态的形式来实现。因为要让任意类的实例都可以使用所以设置所有类的父类Object。
示例：

class Student
{}
class Worker
{}
class Tool{
private Object obj;
public void setObject(Object obj){
this.obj = obj;
}
public Object getObject(){
return obj
}
}
class  {
public static void main(String[] args) {
Tool t = new Tool();
t.setObject(new Student());
Student s = (Student)t.getObject()//需要对其向下转型object转student
//t.setObject(new worker());
//Student s = (Student)t.getObject()就会报类型转换错误异常
}
}

因为早期使用Object来完成扩展，后面还需要对其转型使用，若不注意容易导致编译时期JVM看不出来问题但是用户运行时会报错。
所以在JDK1.5升级后我们就可以定义泛型类实现，原理一样。
示例：

class Student
{}
class Worker
{}
class Tool<W>{
private W w;
public void setW(W w){
this.w = w;
}
public W getW(){
return w;
}
}
class  {
public static void main(String[] args) {
Tool<Student> t = new Tool Student> ()<;
　　//加上泛型由我们指定哪个类型来使用工具类
t.setW(new Student());
Student s = t.getW();
//不用再强转。
}
}

那什么时候定义泛型类？

当类中要操作的引用数据类型不确定时候。
泛型除了定义在类上还可以定义在方法上
泛型方法：

因为泛型类定义的泛型，在整个类中有效，如果被对方使用，那么泛型类的对象明确要操作的具体类型后，所要操作的类型就已经固定了。
为了让不同方法可以操作不用类型，而且类型还不确定，那么可以将泛型定义在方法上。
示例：

lass Demo{
public <T> void show(T t)//泛型定义在方法上{
System.out.println("Hello show!"+t);
}
public <T> void run(T t)//泛型定义在方法上{
System.out.println("Hello run!"+t);
}
}
class FanXingDemo {
public static void main(String[] args)
{
Demo d = new Demo();
d.show("kj");
d.show(3);
d.run(3);
}
}

使用泛型方法，你传什么类型他就是什么类型了
注意：静态方法不可以访问类上定义的泛型。
为什么？因为Demo<T>类上的T是new对象后才能明确，静态方法使用时，对象还没有建立所以就不能使用。
如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。
泛型接口代码示例：

Interface Iner<T>{
Void show(T t);
}
Class InerImp<T> implements Iner<t>{
Public void show(T t){
System.out.println(“show:”+t);
　　}
}
Class FanXingDemo2{
Public static void main(Sting[] args){
InerImp<String> in = new InerImp<String> ();
In.show(“rtyu”);
　　}
}

泛型高级应用

泛型限定：是用于泛型的扩展用的。
？通配符，也可以理解为占位符。
？ extends E：可以接收E类型或者E 的子类型，向上限定。
？ super E：可以接收E类型或者E的父类型，向下限定。
示例：

import java.util.*;
class Person{
private String name;
Person(String name){
this.name = name;
}
public String getName(){
return name;
}
}
class Student extends Person{
Student(String name){
super(name);
}
}
class FanXingDemo3{
public static void main(String[] args) {
ArrayList<Person> al = new ArrayList<Person>();
al.add(new Person("lisi"));
al.add(new Person("lisi"));
al.add(new Person("lisi"));
al.add(new Person("lisi"));
getIt(al);
ArrayList<Student> al1 = new ArrayList<Student>();
al1.add(new Student("lisi1"));
al1.add(new Student("lisi2"));
al1.add(new Student("lisi3"));
al1.add(new Student("lisi4"));
getIt(al1);

}
public static void getIt(Collection< ?extends Person> al){
for (Iterator<?extends Person> it = al.iterator();it.hasNext() ; ){
System.out.println(it.next().getName());
}
}
}

泛型限定2

如：在TreeSet集合中，需要对其存储对象比较
若只是指定当前类型就只能比较当前对象，
但是指定他们的父类型，就都可以指定了，不用再多写比较器了
示例：

import java.util.*;
class Person{
private String name;
Person(String name){
this.name = name;
}
public String getName(){
return name;
}
}
class Student extends Person{
Student(String name){
super(name);
}
}
class Worker extends Person{
Worker(String name){
super(name);
}
}
class Cmp implements Comparator<Person>
{//定义比较器，若只是指定当前类型就只能比较当前对象，
//但是指定他们的父类型，就都可以指定了，不用再多写比较器了
public int compare(Person p1,Person p2){
return p1.getName().compareTo(p2.getName());
}
}
class Demo {
public static void main(String[] args) {
TreeSet<Person> al = new TreeSet<Person>(new Cmp());
al.add(new Person("lisi2"));
al.add(new Person("lisi3"));
al.add(new Person("lisi4"));
al.add(new Person("lisi2"));
getIt(al);
TreeSet<Student> al1 = new TreeSet<Student>(new Cmp());
al1.add(new Student("lisi1"));
al1.add(new Student("lisi23"));
al1.add(new Student("lisi43"));
al1.add(new Student("lisi64"));
getIt(al1);
}
public static void getIt(Collection< ?extends Person> al){
for (Iterator<?extends Person> it = al.iterator();it.hasNext() ; ){
System.out.println(it.next().getName());
}
}
}打印结果：

Map集合

概述：
Map<K,V>，Map集合和Collection接口一样是顶层接口。
基本特点：
该集合是存储键值对，是一对一对忘集合里面存储，而且要保证键的唯一性。
常用方法：
添加：
1， put(K ket,Value) 添加元素，如果出现添加时，相同的键，那么后添加的值会覆盖原 有键对应值，并put方法会返回被覆盖的值。
2， putAll(Map<? Extends K,?extends V> m)添加一个集合
删除：
1， clear()清空
2， remove(Objet key) 删除集合里的指定元素
判断：
1， containsValue(Obect value)判断指定值是否存在
2， containsKey(Object key)判断指定键是否存在
3， isEmpty()判断是否为空
获取：
1， V get(Object obj)通过键获取值
2， size()获取集合长度
3， Collection<V>values()返回此集合中所有的值，返回类型是一个集合
Set<Map.entry<K,V>>entrySet()返回包含的映射关系视图
Set<K>keyset();返回映射中包含的键Set视图。
Map集合的子类

Map
|--Hashtable:底层是哈希表数据结构，不可以存入null键，集合是线程同步的。JDK1.0效率第。
|--HashMap:底层是哈希表数据结构，允许使用null值和null键，该集合是不同步的。JDK1.2效率高
|--TreeMap;底层是二叉树数据结构，线程不同步，可以用于给map集合中的键进行排序
注意：
1， 在添加元素，如果出现添加时相同的键，那么后添加的值会覆盖原有键对应的值。并put方法会返回被覆盖的值。
2， 在通过get方法的返回值来判断一个键是否存在，通过返回null来判断。
Map集合的两种取出方式：
方式一：
Set<v> keySet：将map中所有的键存入到Set集合中，因为set具备迭代器，所有的键可以迭代方式取出所有的键，根据get方法，获取每一个键对应的值。
Map集合的取出原理：将map集合转成set集合，再通过迭代器取出。
示例：

import java.util.*;
class  MapDemo1{
public static void main(String[] args) {
HashMap<String,String>map = new HashMap<String,String>();
map.put("lisi","22");
map.put("zhangsan","34");
map.put("wangwu","56");
map.put("xiaoba","11");
Set<String>keyset = map.keySet();//把map集合里的所有键取出。
Iterator<String>it = keyset.iterator();
while (it.hasNext()){
String key = it.next();//获取每一个键
String value = map.get(key);//根据键获取值。
System.out.println("key:"+key+"value:"+value);
}
}
}

方式二：
Set<Map.Entry<k,v>> entrySet()：将map集合的映射关系存入到了set集合中，而这个关系的数据类型就是Map.Entry，我们可以根据这个关系来获取键和对应的值。
简单说：关系是结婚证，可以根据结婚证来获取丈夫和妻子。
示例：

import java.util.*;
class  MapDemo2{
public static void main(String[] args) {
HashMap<String,String>map = new HashMap<String,String>();
map.put("lisi","22");
map.put("zhangsan","34");
map.put("wangwu","56");
map.put("xiaoba","11");
//通过entrySet()方法，获取器映射关系即Map.Entry,同时还要知道键值的泛型是String类型
Set<Map.Entry<String,String>> sme = map.entrySet();
//迭代取出关系，返回类型一样
Iterator<Map.Entry<String,String>> it = sme.iterator();
while (it.hasNext()){
Map.Entry<String,String> me = it.next();
String key = me.getKey();取出键
String value = me.getValue();取出值
System.out.println("key:"+key+"value:"+value);
}
}
}

深入分析：
为什么映射关系的类型是Map.Entry?
其实Entry也是接口，他是Map接口中的一个内部接口。

interface Map{
public static interface Entry{
public abstract Object getKey();
public abstract Object getValue();

}
}

为什么把Entry定义成Map的内部接口？

因为Entry代表一种关系，但是现有Map才有关系，是属于Map的内部事物，所以才定义成内部规则。比如，心脏是人体内的事物，必须要定义内部规则，一样道理。
Map练习：

*
需求：每一个学生都有一个对应的归属地，学生Student，地址String
学生属性：姓名，年龄
注意姓名和年龄相同的视为同一个学生，保证唯一性
*/
import java.util.*;
class Student implements Comparable<Student>{//实现Comparable接口并定义泛型
private String name;
private int age;
Student(String name,int age){
this.name = name;
this.age = age;
}
public int compareTo(Student s){//复写compareTo方法
int num = new Integer(this.age).compareTo(new Integer(s.age));
if(num==0)
return this.name.compareTo(s.name);
return num;
}
public int hashCode(){
return name.hashCode()+age*77;
}
public boolean equals(Object obj){
if(obj instanceof Student)
throw new ClassCastException("类型转换异常");
Student s = (Student)obj;
return this.name.equals(s.name)&&this.age==s.age;
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
public String toString(){
return name+""+age;
}
}
class HashMapDemo3{
public static void main(String[] args) {
HashMap<Student,String> hm = new HashMap<Student,String>();
hm.put(new Student("lisi1",33),"beijing");
hm.put(new Student("lisi2",23),"shanghai");
hm.put(new Student("lisi3",11),"wuhan");
hm.put(new Student("lisi4",44),"sichuan");
hm.put(new Student("lisi5",22),"beijing");
//第一种取出方式
Set<Student>ss1 = hm.keySet();//将学生键存储进集合
Iterator<Student> it1 = ss1.iterator();
while (it1.hasNext()){
Student key = it1.next();
String value = hm.get(key);
System.out.println(key+"地址是："+value);
}
//第二种取出方式
Set<Map.Entry<Student,String>> ss2 = hm.entrySet();
Iterator<Map.Entry<Student,String>> it2 = ss2.iterator();
while (it2.hasNext()){
Map.Entry<Student,String> myentry = it2.next();
Student stu = myentry.getKey();
String str = myentry.getValue();
System.out.println(stu+"地址是      ："+str);
}
}
}

打印结果如图：



如果需要对学生对象进行年龄进行升序排序。我们可以加入比较器，因为数据是以键值对形式存在的，所以要使用可以排序的Map集合，TreeMap
练习：
/*
需求：获取字符串中字母出现的次数，“qwertyuiasdfghjqwertyusdfghjsdf”
希望打印结果是a(1)c(2).....
通过结果发现每一个字母都对应相应的次数，说明字母和次数键存在映射关系
这时需要使用Map集合
思路：
1，因为要对每一个字母操作，所以需要字符串转成字符数组
2，对应map集合，因为打印结果的字母有顺序，所以使用trremap集合
3，遍历数组，将每一个字母作为键去map集合中查找
若返回null就将字母和1存入map集合
若返回！null说明该字母在集合中有对应的次数那么就将该次数自增一次，
再存入map集合覆盖原有次数
4，将map集合中的数据转变成指定字符串输出。
*/

import java.util.*;
class MapDemo4{
public static void main(String[] args) {
String s = Demo_1("qwertyuqwertyusdfsgdsdsfsdf");
System.out.println(s);
}
public static String Demo_1(String str){
//将传进来的字符串转成字符数组
char[] ch = str.toCharArray();
//建立TreeMap集合，因为不能接受基本数据类型，所以使用数据包装类。
TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
int count = 0;//计数器记录次数
for (int x=0;x<ch.length ;x++ )
{//遍历到的数据不是字母时，就继续循环
if(!(ch[x]>='a'&&ch[x]<='z')||((ch[x]>='A'&&ch[x]<='Z')))
continue;
//根据键获取值
Integer value = tm.get(ch[x]);
//若值不为null将自增后的次数赋值
if (value!=null)
count = value;
//如果值为null
count++;
tm.put(ch[x],count);
count=0;//清零
}//定义缓冲区存储键和值
StringBuilder sb = new StringBuilder();
//将键值映射关系存储进集合
Set<Map.Entry<Character,Integer>> s = tm.entrySet();
Iterator<Map.Entry<Character,Integer>> it = s.iterator();
//取出映射关系
while (it.hasNext())
{
Map.Entry<Character,Integer> ss = it.next();
Character key = ss.getKey();
Integer value = ss.getValue();
sb.append(key+"("+value+")");//添加进缓冲区
}
return sb.toString();
}
}打印结果如图：

Map集合的扩展知识
因为map集合具备映射关系，而在实际中许多都是一对多的关系，比如一个学校对应多个班级，一个班级对应多个学生对象，一个学生对象对应其多个属性。这样的映射关系，就形成了一个映射体系。相当于大集合套小集合，把小集合作为映射的对象
示例：
班级对应学生
"yureban" student("01","wangwu")
"yureban" student("01","zhouqi")

"jiuyeban" student("12","lisi")
"jiuyeban" student("13","zhangsan")
学校对应班级
"czbk" "yureban"
"czbk" "jiuyeban"
打印全校学生的信息：

import java.util.*;
class Demo5{
public static void main(String[] args) {

//预热班学生集合
HashMap<String,String>yureban = new HashMap<String,String>();
//就业班学生集合
HashMap<String,String>jiuyeban = new HashMap<String,String>();
//学校班级集合
HashMap<String,HashMap<String,String>>czbk = new HashMap<String,HashMap<String,String>>();
//添加班级进学校班级集合
czbk.put("yureban",yureban);
czbk.put("jiuyeban",jiuyeban);
//添加预热班学生进集合
yureban.put("01","wangwu");
yureban.put("02","zhouqi");
//添加就业班学生进集合
jiuyeban.put("12","lisi");
jiuyeban.put("13","zhangsan");

getAllStudent(czbk);
}
//定义一个获取全部学生信息的集合,
public static void getAllStudent(HashMap<String,HashMap<String,String>> hm){
Iterator<String> it1 = hm.keySet().iterator();
while (it1.hasNext()){
//返回班级名称
String s = it1.next();
System.out.println(s+"：");
//返回班级学生集合
HashMap<String,String> hs = hm.get(s);
getStudent(hs);
}
}
public static void getStudent(HashMap<String,String> hm){
Iterator<String> it2 = hm.keySet().iterator();
while (it2.hasNext()){
//返回学生姓名
String name = it2.next();
//返回学生id
String id = hm.get(name);
System.out.println(name+":"+id);
}
}
}打印结果：

集合框架工具类之Conllections

概述：
Conllections是集合框架中的一个工具类，该工具内的方法都是静态方法，不需要创建对象，没有封装特有数据。
在Conllections工具类中，大部分方法是用于对List集合进行操作。
常见特有操作

查找：
1，T max(Conllectin<? extends T>coll);根据coll集合里面的自然顺序查找集合里的最大元素。
2，T max(Conllection<? extends T>coll,Comparator<? Super T>comp);根据指定的comp比较器查找coll集合里的最大元素。
替换：
1， void fill(List<? Super T>list,T obj);将list集合里的全部元素替换成指定对象obj。
2， boolean replaceAll(List<T>list,T oldvalue,T newvalue);把list集合中的旧值用新值替换
3， void swap(List list,int I,int b);指定列表集的指定两个位置进行置换。
排序：
1， void shuffle(List<T> list);对指定list集合中的元素进行默认随机排序。
2， void sort(List<T> list);对指定list集合中的元素进行自然顺序的排序。
3， void sort(List<T> list,Comparator<?super T>comp);根据指定比较器的排序方式来对指定list集合进行排序。
反转：
1， reverse(List<?> list);对指定list集合进行反转。
2， Comparator reverseOrder();返回一个比较器，强行逆转了实现Comparable接口的对象的自然顺序
3， Comparator reverseOrder(Comparator<T> comp)；返回一个比较器，强行逆转了指定比较器的顺序
集合同步：

通常常用的集合都是不安全的，因为高效，如果多线程要操作这些集合，可以通过Collections提供的同步方法，将线程不安全的集合转换成安全的。
1， List<T>synchronizedList(List<T> list);返回支持的同步（线程安全的）List集合。
2， Map<K,V>synchronizedList(Map<K,V> m);返回支持的同步（线程安全的）Map集合。
示例练习：
/*
需求：对指定list集合中的指定部分元素进行替换，
要求使用Collections中的fill方法。
分析：
1，需要对集合指定的部分元素取出，存储进新的集合
2，使用fill方法对新集合的元素进行替换
3，新集合的元素添加进list集合。
*/

import java.util.*;
class  FillDemo{
public static void main(String[] args) {
ArrayList<String>list = new ArrayList<String>();
list.add("rytuy");
list.add("fdsd");
list.add("yrt");
list.add("cv");
//替换前集合
System.out.println(list);
//对集合指定部分替换
fillSome(list,0,2,"java");
//替换后集合
System.out.println(list);
}
public static void fillSome(List<String>list,int start,int end,String str){
if(start>end)
throw new RuntimeException("插入位置非法");
//定义临时集合
List<String> list1 = new ArrayList<String>();
//获取list集合中指定的要置换的元素
//因为在start取一个，后面的一个就变成了start，而让y控制次数
for (int x=start,y=start;y<=end ;y++)
{//获取一个就往临时集合存储一个
list1.add(list.get(x));
//移除list集合需要替换的元素
list.remove(x);
}
//将临时集合的元素替换
Collections.fill(list1,str);
//从start位置开始把临时集合里的元素插入进原集合
list.addAll(start,list1);
}
}打印结果如图：

集合框架工具类之Arrays

概述
此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。
Arrays是集合框架中的一个工具类，该工具内的方法都是静态方法，不需要创建对象，没有封装特有数据。
常见方法：具体查看API文档java.util.Arrats类的方法
binarySearch():使用二分查找
copyOf():
copyOfRange():
deepToString():如果两个指定数组彼此是深层相等 的，则返回 true。
equals()判断某类型数组彼此是否相等
fill()将指定的某类型值分配给某类型数组
hashCode():对指定数组内容返回哈希码值
sort():对指定的数组进行排序
toString();将指定数组内容以字符串形式返回
数组变集合

static<T> List<T> asList(T…a);将指定数组转变为集合
注意：
1， 将谁转换成集合，不可以使用集合的增删方法，因为数组的长度是固定了。如果进行了增删操作，会发生不可以操作异常UnsupportedOperationException
2， 如果数组中的元素都是对象，那么变成集合时，数组中的元素转为集合中的元素。
3， 如果数组中的元素是基本数据类型，那么变成集合时，数组将作为集合元素存在。
示例：

import java.util.*;
class ArraysDemo {
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args) {
asListDemo();
}
public static void asListDemo()
{//字符串数组转集合
String[] str = {"wer","sdg","java","array","nihao"};
List list = Arrays.asList(str);
sop(list);
/*基本数据类型不能转集合
int[] in = {1,2,3,4,5};
List list = Arrays.asList(in);
sop(list);*/
}
}

集合变数组

Collection接口中的toArray方法
<T> T[] toArray(T[] a);返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。
注意：
1， 指定类型的数组到底要定义多长呢？
当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。所以创建一个刚刚好的数组最优。
2， 为什么将集合变数组？
为了限定对元素的操作。不需要进行增删了。和数组变集合道理一样。
示例：

import java.util.*;
class  CollectionToArray{
public static void main(String[] args){
ArrayList<String> al = new ArrayList<String>();{
al.add("abc1");
al.add("abc2");
al.add("abc3");
//将集合变为String数组
String[] arr = al.toArray(new String[al.size()]);
//利用Arrays操作数组的方法
System.out.println(Arrays.toString(arr));
}
}

1.5版本新特性

增强for循环

用于对集合的遍历，和iterator功能类似，他的底层结构还是iterator，是为了简化书写。
格式：
for (数据类型变量名：被遍历的集合(Collection)或者数组)
{执行语句}
注意：
高级for循环对集合进行遍历时，只能获取集合元素，但是不能对集合进行操作。
而迭代器除了遍历还可以进行remove集合中的元素的动作。
如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。
传统for和高级for有神马区别？
高级for有一个局限性，必须有被遍历的目标。
建议在遍历数组的时候，还是希望用传统for，因为传统for可以定义角标。
示例：

import java.util.*;
class  AdvForDemo{
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args) {
HashMap<Integer,String> hs = new HashMap<Integer,String>();
hs.put(1,"java1");
hs.put(2,"java2");
hs.put(3,"java3");
hs.put(4,"java4");
getFor_1(hs);
getFor_2(hs);
}
public static void getFor_1(HashMap<Integer,String> is){
//用keySet方法取出键
Set<Integer>keyset = is.keySet();
for (Integer i: keyset)
{
String value = is.get(i);
sop(i+":"+value);
}
}
public static void getFor_2(HashMap<Integer,String> is2){
//用entrySet方法取出键值
for(Map.Entry<Integer,String> keyset2:is2.entrySet()){
Integer in = keyset2.getKey();
String str = keyset2.getValue();
sop(in+":       "+str);
}
}
}

1.5版本新特性

可变参数

如果一个方法在参数列表中传入多个参数，当参数个数不确实时，每次都要重载其方法比较麻烦，这时可以用数组作为形式参数传入，但是每次还是要定义一个数组对象，所以在1.5版本后，java提供了一个新特性即可变参数。
其实可变参数就是数组参数的简写形式，不用每次都手动的建立数组对象。只要将要操作的元素作为参数传递即可。他是隐式的将这些参数封装成了数组。
注意：
可变参数一定要定义在参数列表的最后面。
示例：

class  ParamMethodDemo{
public static void main(String[] args){
show("haha",2,3,4,5,6);
}
public static void show(String str,int... arr)//...就表示可变参数{
System.out.println(arr.length);
}
}

1.5版本新特性



静态导入

静态导入类似于import导入java相关类，它导入的是静态成员，这样在编写程序时可以减少书写
格式：
import static java.util.Arrays.*;//导入了Arrays类中的所有静态成员。
Import static java.lang.System.*;//导入了System类中的所有静态成员。
注意：
1，当导入没有加上static时导入的是某一类
当加上static时导入的是某一类中的静态成员。
2，当类名重名时，需要指定具体的包名
当方法重名时，指定具备所属的对象或者类。
示例：

import java.util.*;
import static java.util.Arrays.*; //导入了Arrays类中的所有静态成员。
import static java.lang.System.*; //导入了System类中的所有静态成员。
class  StaticImport
{
public static void main(String[] args){
out.println("haha");//省略书写System.
int[] arr = {3,1,5};
sort(arr);//使用Arrays工具类的方法sort时就可以省略书写Array.
int index = binarySearch(arr,1);
out.println("Index="+index);
//当没有指定继承时，所以类默认继承了Object，
//因为toString方法object都具备，所以为了区分，必须写上具体调用者
System.out.println(Arrays.toString(arr));
}
}

----------------------
ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------详细请查看：http://edu.csdn.net