java_集合 – 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();
       }
}

 

發佈留言