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();
}
}