黑馬程序員java學習筆記，集合

集合類
數組只能存儲固定長度的，集合是可變的，數組只能存儲基本數據類型，集合可以存儲對象，長度是不固定的
java.util package 中
Collection List Set
ArrayList LinkedList Vector HashSet TreeSet

ArrayList a1=new ArrayList();
集合中存放的不是對象實體，只是對象地址
a1.add("kingkong");
a1.add("Jack");
a1.add("Rose");
a1.add("Sam");
Iterator it=a1.iterator();
while(it.hasNext()){ //獲取迭代器，用於取出集合中的元素
it.next();
}
或者用for循環寫
   for(Iterator it=a1.iterator();it.hasNext();){
  it.next();
   }

   List 中元素是有序的，元素是可以重複的，因爲該集合有索引
  ArrayList 底層使用的是數組結構，查詢速度很快，但是增刪稍慢
  LinkedList 底層使用的是鏈表數據結構，增刪速度很快，查詢稍慢
  Vector 底層是數組結構，線程同步，被ArrayList替代
   Set 中元素是無序的，元素是不可以重複的
-----------------------------------------------------------------------
   List：特有方法，凡是可以操作角標的都是List的對象
   增
      add(index,element);
   addAll(index,element);
刪
    remove(index);
改
    set(index,element);
查
    get(index);
    subList(from,to);
    listIterator();
for(int x=0;x<a1.size();x++)

ArrayList a1=new ArrayList();
Iterator it=a1.iterator();
ListIterator li=a1.ListIterator();//List所特有的迭代器

while(li.hasNext()){
Object obj=li.next();
if(obj.equals("kingkong"))
  li.set(obj);
}
while(it.hasNext()){
Object obj=it.next();
if(obj.equals("kingkong"))

  //it.remove();//將kingkong刪除
}
List 集合的特有的迭代器，ListIterator是Iterator的子接口
在迭代時，不可以通過集合對象方法操作集合中的元素
因爲會發生ConCurrentModificationException異常
所以在迭代器時，只能用迭代器的方法操作元素，可是Iterator方法是有限的
***********************************************************
LinkedList 中特有的方法
    addFirst();或者offerFirst();
addLast();或者offerLast();
    getFirst();或者peekFirst(); 後面的新方法不會產生異常
getLast();或者peekLast();
removeFirst();或者poolFirst();
removeLast();或者poolLast();
LinkedList link=new LinkedList();
link.add("kingkong");
link.addLast("Jack");
**************************************************************************************************8
Set集合的功能和Collection功能是一樣的
HashSet 底層結構式哈希表，線程是非同步的
    保證元素唯一性的原理，判斷hashCode值是否相同
如果相同，還會繼續判斷元素的equals方法，是否爲true
HashSet是通過元素的兩個方法，hashCode和equals來完成
如果元素的兩個方法，hashCode和equals來完成
如果元素的HashCode值相同，纔會判斷equals是否爲true
如果元素的HashCode值不同，不會調用equals
對於判斷元素是否存在，以及刪除等操作，依賴的方法是元素的hashCode和equals方法
TreeSet 底層結構式二叉樹，可以對集合中的元素進行排序
保證元素唯一性的依據：compareTo方法return 0；

TreeSet排序的第一種方式，讓元素具備比較性
元素要實現Comparable接口，覆蓋compareTo方法

TreeSet的第二種排序方式
    當元素不具備比較性，或者具備的比較性不是所需要的
    這時就需要讓集合自身具備比較性
    在集合初始化時就有比較性

HashSet hs=new HashSet();

hs.add("kingkong");
hs.add("Jack");
hs.add("Rose");
自定義對象必須複寫函數的equals和hashCode
hs.contains(new Person("a1",11));
hs.remove(new Person());
*****************************************************************************
class Student implements Comparable{
  public int comparaTo(){
   if(!(obj instanceof Student))
    throw new RuntimeException("is not Student instance");
   Student s=(Student)obj;
   if(this.age>s.age)
    return 1;
   if(this.age==s.age){
    return this.name.compareTo(s.name);
   }
   return -1;

  }
}
TreeSet ts=new TreeSet();
********************************************************************************************
泛型
用於解決安全問題，是一個安全機制
ArrayList<String> a1=new ArrayList<String>();

//迭代器也需要泛型表示
Iterator<String> it=a1.iterator<String>();

1.將運行時期的問題ClassCastException,轉移到了編譯時期
2.避免強制轉換類型

在使用java提供的對象時，什麼時候寫泛型
    在集合框架中很常見，只要見到<>就得定義泛型
<>就是用來接收類型的
當使用集合時，將集合中要要存儲的數據類型作爲參數傳遞到<>中
當自定義對象，必須定義hashCode和equals方法，還得實現comparable接口，複寫其中的compareTo方法，使其具備默認比較性
TreeSet<Sting> ts=new TreeSet<String>();
ts.add("kingkong");
    ts.add("Jack");
Iterator<String>it=new Iterator<String>();
    while(it.hasNext()){
  String s=it.next();
}
class LenCompatator implements Comparator<String>(){
  public int compare(String s1,String s2){
   int num=new Integer(s1.length()).compateTo(new Integer(s2.length()));
   if(num==0)
    return s2.compareTo(s1);
   return num;
  }
}

class Worker{

}
class Tool{
private Object obj;
public void setWorker(Object obj){
  this.obj=obj;
}
public Object getWorker(){
  return obj;
}
}
//泛型類，當不確定其中的引用順序不確定，可以定義泛型
class Utils<Type>{
private Type type;
public void setObject(Type type){
  this.type=type;
}
public Type getObject(){
  return type;
}
}
/*
class Tool{
private Worker worker;
public void setWorker(Worker worker){
  this.worker=worker;
}
public Worker getWorker(){
  return worker;
}
}
**/
靜態方法泛型
class Demo<T>{
public void show(T t){
  System.out.println(t);
}
public <E> void print(E e){
  System.out.println(e);
}
//靜態方法不可以訪問類上定義的泛型
   如果靜態方法的操作的應用不確定，可以將泛型定義在方法上

   public static <W>void method(W t){
   System.out.println(t);
   }
}
泛型定義在接口上
   interface Inter<T>{
  void show(T t);
   }
   class InterImpl extends Inter<String>{
  public void show(String s){
   System.out.println(s);
  }
   }
class InterImpl<T> implements Iner<T>{
  public void show(T t){
   System.out.println(t);
  }
}
靜態方法不可以訪問類上定義的泛型
如果靜態方法操作的應用數據類型不確定，可以將泛型定義在方法上
方法上的泛型標誌放在返回值的前面，修飾符的後面
泛型限定
? 是通配符，也可以理解爲佔位符
<? extends E>可以接受E類型或者E的子類型，上限
<? super E> 可以接受E類型或者E的父類型，下限
public static void printColl(ArrayList<? extends Person>a1){
Iterator<? extends Person>it=a1.iterator();
}
public static void printColl(ArrayList<？> a1){
Iterator<?> it=a1.iterator();
while(it.hasNext()){
  System.out.println(it.next());
}
}
***************************************************************************************************
Map集合:該集合存儲鍵值對，一對一對的存儲
添加
put()
putAll()
刪除
    clear()
remove()
判斷
isEmpty()
獲取
get()
size()
values()
keySet()
entrySet()
HashTable:底層是哈希表數據結構，線程同步，不可以存入null鍵null值
       必須實現hashC和equals方法

HashMap：哈希表數據結構，允許使用null值和鍵，不同步
  必須實現hashC和equals方法和CompareTo方法
TreeMap：底層是二叉樹，線程不同步，可以用於給map集合中的鍵進行排序
Map<String,String> map=new HashMap<String,String>();
map.put("01","kingkong");
map.put("02","Jack");
添加相同的值，會覆蓋原來的值
map.remove("02");
map.containsKey("02");
Map<Sting,String> map=new HashMap<Sting,string>();
map.put("01","kingkong");
map.put("02","Jack");
Set<String>keySet=map.keySet();
Iterator<String>it=keySet.iterator();
while(it.hasNext()){
  String key=it.next();
  //有了鍵就可以通過map集合的get方法獲取其對應的value
  String value=map.get(key);
  //將Map中的映射關係取出，存入到Set集合中
  Set<Map.Entry<String,String>> entrySet=map.entrySet();
  Iterator<Map.Entry<String,String>>it=entrySet.iterator();
  while(it.hasNext()){
   Map.Entry<String,String>me=it.next();
   String key=me.getKey();
   String value=me.getValue();
  }
}
實現CompareTo方法

Arrays是對數組操作的工具類
asList：將數組變成List集合
List<String>list=Arrays.asList(arr);

增強for循環
   迭代器除了遍歷，還可以進行remove集合中元素的動作
   如果是用ListIterator,還可以再遍歷過程中對集合進行增刪改查的操作
     ArrayList<String>a1=new ArrayList<String>();
     a1.add("kingkong");
a1.add("Jack");
for(String s: a1){ //只能取出不能對集合進行操作
  System.out.println(s);
}
int[] arr={2,4,6};
for(int x:arr){
  System.out.println(x);
}
--------------------------------------------------
Properties 是hashtable的子類，具備map集合的特點，而且裏面存儲的鍵值對是字符串

是集合中和IO技術想結合的集合容器

該對象的特點：可以用於鍵值對形式的配置文件
設置和獲取元素
public static void setAndGt(){
Properties prop=new Properties();

prop.setProperty("john","10");
prop.setProperty("jack","87");

String value=prop.getProperty("jack");

Set<String> names=prop.stringPropertyNames();

for(String s:names){
sop(prop.getProperty(s));
}
}

黑馬程序員java學習筆記，集合

黑馬程序員java學習第四天，數組以及排序算法

黑馬程序員java學習，IO字節流及File

黑馬程序員java學習第一天，基礎篇

你所應該知道的Dom4J

黑馬程序員java學習筆記，集合

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結