首页 诗词 字典 板报 句子 名言 友答 励志 学校 网站地图
当前位置: 首页 > 教程频道 > 开发语言 > 编程 >

java_会合

2012-09-10 
java_集合Collection|--List:元素是有序的,元素可以重复。因为该集合体系有索引。|--ArrayList:底层的数据结

java_集合

Collection

       |--List:元素是有序的,元素可以重复。因为该集合体系有索引。

              |--ArrayList:底层的数据结构使用的是数组结构。特点:查询速度很快。但是增删稍慢。线程不同步。

              |--LinkedList:底层使用的链表数据结构。特点:增删速度很快,查询稍慢。线程不同步。

              |--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。

 

       |--Set:元素是无序,元素不可以重复。、

 

1,添加

       add(e);

       addAll(collection);

 

2,删除

       remove(e);

       removeAll(collection);

       clear();

 

3,判断。

       contains(e);

       isEmpty();

 

4,获取

       iterator();

       size();

 

5,获取交集。

       retainAll();

 

6,集合变数组。

       toArray();

 

7,查

       get(index):

       subList(from,to);

       listIterator();

       intindexOf(obj):获取指定元素的位置。

       ListIteratorlistIterator();

 

1,add方法的参数类型是Object。以便于接收任意类型对象。

2,集合中存储的都是对象的引用(地址)

 

迭代器是取出方式,会直接访问集合中的元素。

所以将迭代器通过内部类的形式来进行描述。

通过容器的iterator()方法获取该内部类的对象。

 

在迭代时循环中next调用一次,就要hasNext判断一次。

              Iteratorit = al.iterator();

             

while(it.hasNext())

              {

                     sop(it.next()+"...."+it.next());

              }

             

 

LinkedList:特有方法:

addFirst();

addLast();

 

getFirst();

getLast();

获取元素,但不删除元素。如果集合中没有元素,会出现NoSuchElementException

 

removeFirst();

removeLast();

获取元素,但是元素被删除。如果集合中没有元素,会出现NoSuchElementException

 

在JDK1.6出现了替代方法。

 

offerFirst();

offerLast();

 

peekFirst();

peekLast();

获取元素,但不删除元素。如果集合中没有元素,会返回null。

 

pollFirst();

pollLast();

获取元素,但是元素被删除。如果集合中没有元素,会返回null。

 

 

|--Set:元素是无序(存入和取出的顺序不一定一致),元素不可以重复。、

       |--HashSet:底层数据结构是哈希表。是线程不安全的。不同步。

                     HashSet是通过元素的两个方法,hashCode和equals来完成。

                     如果元素的HashCode值相同,才会判断equals是否为true。

                     如果元素的hashcode值不同,不会调用equals。

 

                     注,对于判断元素是否存在,以及删除等操作,依赖的方法是元素的hashcode和equals方法。

 

Set集合的功能和Collection是一致的。

 

 

枚举就是Vector特有的取出方式。

其实枚举和迭代是一样的。

 

class VectorDemo

{

       publicstatic void main(String[] args)

       {

              Vectorv = new Vector();

 

              v.add("chrp01");

              v.add("chrp02");

              v.add("chrp03");

              v.add("chrp04");

 

              Enumeration en = v.elements();

              while(en.hasMoreElements())

              {

                     System.out.println(en.nextElement());

              }

       }

}


Set:无序,不可以重复元素。

       |--HashSet:数据结构是哈希表。线程是非同步的。

                            保证元素唯一性的原理:判断元素的hashCode值是否相同。

                            如果相同,还会继续判断元素的equals方法,是否为true。

 

       |--TreeSet:可以对Set集合中的元素进行排序。

                            底层数据结构是二叉树。

                            保证元素唯一性的依据:

                            compareTo方法return 0.

 

                            TreeSet排序的第一种方式:让元素自身具备比较性。

                            元素需要实现Comparable接口,覆盖compareTo方法。

                            也种方式也成为元素的自然顺序,或者叫做默认顺序。

 

                            TreeSet的第二种排序方式。

                            当元素自身不具备比较性时,或者具备的比较性不是所需要的。

                            这时就需要让集合自身具备比较性。

                            在集合初始化时,就有了比较方式。

 

排序时,当主要条件相同时,一定判断一下次要条件。

 

 

按照字符串长度排序。使用比较器。

 

class TreeSetTest

{

       publicstatic void main(String[] args)

       {

              TreeSetts = new TreeSet(new StrLenComparator());

 

              ts.add("abcd");

              ts.add("cc");

              ts.add("cba");

              ts.add("aaa");

              ts.add("z");

              ts.add("hahaha");

 

              Iteratorit = ts.iterator();

while(it.hasNext())

              {

                     System.out.println(it.next());

              }

       }

}

 

class StrLenComparator implementsComparator

{

       publicint compare(Object o1,Object o2)

       {

              Strings1 = (String)o1;

              Strings2 = (String)o2;

 

              intnum = new Integer(s1.length()).compareTo(new Integer(s2.length()));

              if(num==0)

                     returns1.compareTo(s2);

              returnnum;

       }

}

 

什么时候定义泛型类?

当类中要操作的引用数据类型不确定的时候,

早期定义Object来完成扩展。

泛型格式:通过<>来定义要操作的引用数据类型。

 

当使用集合时,将集合中要存储的数据类型作为参数传递到<>中即可。

 

class GenericDemo

{

       publicstatic void main(String[] args)

       {

              ArrayList<String>al = new ArrayList<String>();

 

              al.add("abc01");

              al.add("abc0991");

              al.add("abc014");

 

              Iterator<String>it = al.iterator();

              while(it.hasNext())

              {

                     Strings = it.next();

                     System.out.println(s+":"+s.length());

              }

       }

}

 

 

? 通配符。也可以理解为占位符。

泛型的限定;

? extends E: 可以接收E类型或者E的子类型。上限。

? super E: 可以接收E类型或者E的父类型。下限

 

public static voidprintColl(Collection<? extends Person> al)

       {

              Iterator<?extends Person> it = al.iterator();

              while(it.hasNext())

              {

                     System.out.println(it.next().getName());

              }

       }

 

 

将字符串中的数值进行排序。使用TreeSet完成。因为TreeSet自身具备排序功能。

 

class TreeSetTest

{

       publicstatic void main(String[] args)

       {

              ArrayListal = new ArrayList();

              Stringstr = "90 -7 0 18 2 45 4";

              String[] arr = str.split(" ");

              TreeSetts = new TreeSet();

 

              for(intx=0; x<arr.length; x++)

              {

                     ts.add(Integer.parseInt(arr[x]));//

              }

              System.out.println(ts);

       }

}



Map集合:该集合存储键值对。一对一对往里存。而且要保证键的唯一性。

       1,添加。

              put(Kkey, V value)

              putAll(Map<?extends K,? extends V> m)

 

       2,删除。

              clear()

              remove(Objectkey)

 

       3,判断。

              containsValue(Objectvalue)

              containsKey(Objectkey)

              isEmpty()

 

       4,获取。

              get(Objectkey)

              size()

              values()

 

              entrySet()

              keySet()

 

Map

       |--Hashtable:底层是哈希表数据结构,不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。

       |--HashMap:底层是哈希表数据结构,允许使用 null 值和 null 键,该集合是不同步的。将hashtable替代,jdk1.2.效率高。

       |--TreeMap:底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。

 

Set底层就是使用了Map集合。

 

import java.util.*;

class MapDemo

{

       publicstatic void main(String[] args)

       {

              Map<String,String>map = new HashMap<String,String>();

 

              //添加元素,如果出现添加时,相同的键。那么后添加的值会覆盖原有键对应值。

              //并put方法会返回被覆盖的值。

              System.out.println("put:"+map.put("01","zhangsan1"));

              System.out.println("put:"+map.put("01","wnagwu"));

              map.put("02","zhangsan2");

              map.put("03","zhangsan3");

 

              System.out.println("containsKey:"+map.containsKey("022"));

             

              System.out.println("get:"+map.get("023"));

 

              map.put("04",null);

              System.out.println("get:"+map.get("04"));

              //可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。

 

              //获取map集合中所有的值。

              Collection<String>coll = map.values();

 

              System.out.println(coll);

              System.out.println(map);

       }

}

 

 

map集合的两种取出方式:

1,Set<k> keySet:将map中所有的键存入到Set集合。因为set具备迭代器。

       所有可以迭代方式取出所有的键,在根据get方法。获取每一个键对应的值。

       Map集合的取出原理:将map集合转成set集合。在通过迭代器取出。

 

2,Set<Map.Entry<k,v>> entrySet:将map集合中的映射关系存入到了set集合中,

                            而这个关系的数据类型就是:Map.Entry

 

                            Entry其实就是Map中的一个static内部接口。

                            为什么要定义在内部,

                            因为只有有了Map集合,有了键值对,才会有键值的映射关系。

                            关系属于Map集合中的一个内部事物。

                            而且该事物在直接访问Map集合中的元素。

 

 

对学生对象的年龄进行升序排序。

 

import java.util.*;

 

class StuNameComparator implementsComparator<Student>

{

       publicint compare(Student s1,Student s2)

       {

              intnum = s1.getName().compareTo(s2.getName());

              if(num==0)

                     returnnew Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));

              returnnum;

       }

}

 

class MapTest2

{

       publicstatic void main(String[] args)

       {

              TreeMap<Student,String>tm = new TreeMap<Student,String>(new StuNameComparator());

 

              tm.put(newStudent("blisi3",23),"nanjing");

              tm.put(newStudent("lisi1",21),"beijing");

              tm.put(newStudent("alisi4",24),"wuhan");

              tm.put(newStudent("lisi1",21),"tianjin");

              tm.put(newStudent("lisi2",22),"shanghai");

             

              Set<Map.Entry<Student,String>>entrySet = tm.entrySet();

 

              Iterator<Map.Entry<Student,String>>it = entrySet.iterator();

 

              while(it.hasNext())

              {

                     Map.Entry<Student,String>me = it.next();

 

                     Studentstu = me.getKey();

                     Stringaddr = me.getValue();

                     System.out.println(stu+":::"+addr);

              }

       }

}


集合框架的工具类。

Collections:集合框架的工具类。里面定义的都是静态方法。

Collections和Collection的区别是:

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

              它有两个常用的子接口,

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

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

Collections是集合框架中的一个工具类。该类中的方法都是静态的

              提供的方法中有可以对list集合进行排序,二分查找等方法。

              通常常用的集合都是线程不安全的。因为要提高效率。

              如果多线程操作这些集合时,可以通过该工具类中的同步方法,将线程不安全的集合,转换成安全的。

 

集合变数组。

Collection接口中的toArray方法。

 

import java.util.*;

class CollectionToArray

{

       publicstatic void main(String[] args)

       {

              ArrayList<String>al = new ArrayList<String>();

              al.add("abc1");

              al.add("abc2");

              al.add("abc3");

             

              //1,指定类型的数组的长度:

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

//            当指定类型的数组长度大于了集合的size,就不会新创建了数组。而是使用传递进//来的数组。

//            所以创建一个刚刚好的数组最优。

//            2,为什么要将集合变数组?

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

 

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

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

       }

}

 

---------------------------------------------------------

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

out:标准输出,默认是控制台。

in:标准输入,默认是键盘。

 

描述系统一些信息。

获取系统属性信息:PropertiesgetProperties();

import java.util.*;

class SystemDemo

{

       publicstatic void main(String[] args)

       {

              Propertiesprop = System.getProperties();

             

//因为Properties是Hashtable的子类,也就是Map集合的一个子类对象。

              //那么可以通过map的方法取出该集合中的元素。

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

              //如何在系统中自定义一些特有信息呢?

System.setProperty("mykey","myvalue");

              //获取指定属性信息。

              Stringvalue = System.getProperty("os.name");

              System.out.println("value="+value);

              //可不可以在jvm启动时,动态加载一些属性信息呢?

              Stringv = System.getProperty("haha");

              System.out.println("v="+v);s

              //获取所有属性信息。

              for(Objectobj : prop.keySet())

              {

                     Stringvalue = (String)prop.get(obj);

                     System.out.println(obj+"::"+value);

              }           

       }

}

-----------------------------

 

Runtime对象

该类并没有提供构造函数。

说明不可以new对象。该类中的方法都是静态的。

该类中还有非静态方法。

说明该类肯定会提供了方法获取本类对象。而且该方法是静态的,并返回值类型是本类类型。

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

 

该方式是staticRuntime getRuntime();

class RuntimeDemo

{

       publicstatic void main(String[] args) throws Exception

       {

              Runtimer = Runtime.getRuntime();

              Processp = r.exec("notepad.exe  SystemDemo.java");

       }

}

 

-----------------------------------------------

获取当前时间:

Date d = new Date();

              System.out.println(d);//打印的时间看不懂,希望有些格式。

//将模式封装到SimpleDateformat对象中。

              SimpleDateFormatsdf = new SimpleDateFormat("yyyy年MM月dd日E hh:mm:ss");

              //调用format方法让模式格式化指定Date对象。

              Stringtime = sdf.format(d);

              System.out.println("time="+time);

              longl = System.currentTimeMillis();

              Dated1 = new Date(l);

              System.out.println("d1:"+d1);

 

---------------------------------------------------------------------

 

字符流和字节流:

 

字节流两个基类:

InputStream   OutputStream

 

字符流两个基类:

Reader Writer

 

既然IO流是用于操作数据的,

那么数据的最常见体现形式是:文件。

在硬盘上,创建一个文件并写入一些文字数据。

找到一个专门用于操作文件的Writer子类对象。FileWriter。 后缀名是父类名。 前缀名是该流对象的功能。

import java.io.*;

class FileWriterDemo

{

       publicstatic void main(String[] args) throws IOException

       {

              //创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。

              //而且该文件会被创建到指定目录下。如果该目录下已有同名文件,将被覆盖。

              //其实该步就是在明确数据要存放的目的地。

              FileWriterfw = new FileWriter("demo.txt");

              //调用write方法,将字符串写入到流中。

              fw.write("abcde");

              //刷新流对象中的缓冲中的数据。

              //将数据刷到目的地中。

              //fw.flush();

              //关闭流资源,但是关闭之前会刷新一次内部的缓冲中的数据。

              //将数据刷到目的地中。

              //和flush区别:flush刷新后,流可以继续使用,close刷新后,会将流关闭。

              fw.close();

       }

}

------------------------------------------------

对已有文件的数据续写。

import java.io.*;

class FileWriterDemo3

{

       publicstatic void main(String[] args) throws IOException

       {

       //传递一个true参数,代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写。

              FileWriterfw = new FileWriter("demo.txt",true);

              fw.write("nihao\r\nxiexie");

              fw.close();

       }

}

----------------------------------

//读取一个.java文件,并打印在控制台上。

import java.io.*;

class FileReaderTest

{

       publicstatic void main(String[] args) throws IOException

       {

              FileReader  fr = newFileReader("DateDemo.java");

              char[]buf = new  char[1024];

              intnum = 0;

              while((num=fr.read(buf))!=-1)

              {

                     System.out.print(newString(buf,0,num));

              }

              fr.close();

       }

}




热点排行