Java高級特性 集合

數據結構:計算機中用來存儲或者管理數據的方式

鏈表底層實現的代碼:

package demo3.lianxi1;

public class MyLink {
private int data;//存儲鏈表的值
private MyLink next;//指針指向下一個數據

public MyLink(int i) {
data=i;
}
//向鏈表中拼接值
private void append(MyLink myLink) {
MyLink s=this;
while(s.next!=null){
s=s.next;
}
s.next=myLink;
}
//向鏈表中增長值,每當增長一個值,都在第一個值的後面
private void add(MyLink myLink) {
myLink.next=next;
next=myLink;
}
//把鏈表中的數據顯示出來
private void show() {
MyLink s = this;
while (s != null) {
System.out.println(s.data);
s = s.next;
}
}
public static void main(String[] args) {
MyLink link=new MyLink(1);
link.append(new MyLink(10));
link.append(new MyLink(20));
link.append(new MyLink(30));
link.add(new MyLink(3));
link.show();
} 

}

數組的特色:

     1.長度一旦被定義,就不容許被改變

     2.在內存中開闢連續的空間

     3.便於查詢,可是插入和刪除麻煩

例子:

   若是咱們建立一個容量爲30的數組,用來存儲學生信息

   1.一個班的學生若是不夠30,形成資源浪費

   2.一個班的學生若是大於30,內存不夠

集合框架:  父接口Collection

Collections一些方法來操做集合類

 Collections 全部集合類的工具類

 @test

public void test01{

 List<String> list=new ArrayList<>();

 list.add("z");

 list.add("a");

 list.add("v");

 list.add("b");

 System.out.println("沒有排序"+list);

 //1.升序--->sort

 Collections.sort(list);

 System.out.println("升序"+list);

//2.降序-->reverse

Collections.reverse(list);

System.out.println("降序"+list);

//3.查詢某個元素在集合中的位置,必須先升序排序-->binarySearch

 Collections.sort(list);

 int index=Collections.binarySearch(list,"z");

 System.out.println("元素z存在的位置是:"+index);

//4.隨機排序---->shuffle

 Collections.shuffle(list);

System.out.println("隨機排序"+list);

}

實現對對象的排序   只有實現Comparable接口的類才能被排序

 

//只有實現Comparable接口的類 才能被 排序！
public class Student implements Comparable {

private int id; // 學生編號
private String name;

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public Student() {
super();
}

@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + "]";
}

public Student(int id, String name) {
super();
this.id = id;
this.name = name;
}

// 按照本身的規則 去進行 排序
@Override
public int compareTo(Object o) {
if (o instanceof Student) {
Student stu = (Student) o;
if (stu.getId() == this.id) {
return 0;
} else if (stu.getId() < this.id) {
return -1;//降序
} else {
return 1;
}
} else {
return 0;
}
}

}

@test

 

public void test02{

List<Student> list=new ArrayList<>();

 list.add(new Student(50,"小黑50"));

 list.add(new Student(10,"小黑10"));

 list.add(new Student(80,"小黑80"));

 list.add(new Student(20,"小黑20"));

 list.add(new Student(60,"小黑60"));

Collections.sort(list);

 for(Student student:list){

 System.out.println(student);

 } 

 

 

}

 

 把數組轉換成集合

@Test
public void test03() {
String[] words = { "a", "b", "c", "d" };
List<String> list = Arrays.asList(words);
Collections.rotate(list, 2);//後移兩位,把後面的兩位移到前面
System.out.println(list);
}

 

中文排序

@Test
public void test04() {
List<String> list = new ArrayList();
list.add("啊");
list.add("在");
list.add("把");
list.add("好");
list.add("是");
Comparator<Object> c = Collator.getInstance(Locale.CHINA);
Collections.sort(list, c);
for (String s : list) {
System.out.println(s);
}
}

數組和...的區別以及用法

/**
* 01.能夠傳遞0 或者 N個 int類型的數據
* 02.怎麼操做數組 怎麼操做...
* 03.必須位於參數列表中的最後一個位置
*/
public static void main(String[] args) {
String[] sales = { "啤酒", "飲料", "礦泉水" };
slaeSometing("小粉");
}

/**
* @param name 誰 在 出售 什麼 東西
* @param something 出售的東西
*/
private static void slaeSometing(String name, String... something) {
System.out.println(name + "在出售");

for (int i = 0; i < something.length; i++) {
System.out.print(something[i] + ",");
}
}

 

     public interface List<E> extends Collection<E>

     public interface Set<E> extends Collection<E>

     public interface Map<k.v>

    Vector  線程安全,可是性能低

    List接口經常使用的實現類  

     存儲的都是不惟一(能夠重複),有序(插入順序)的數據   

 

       ArrayList底層就是一個動態數組,自動擴容

          List lis=new ArrayList();

 

public ArrayList() {
this.elementData = EMPTY_ELEMENTDATA;
}

private static final Object[] EMPTY_ELEMENTDATA = {};
private transient Object[] elementData;

       

          咱們在執行add();的時候,底層默認初始化了一個長度爲10的數組,能夠自動擴容1.5           倍

           Object[] elementData=new  Object[10];

         s.size();集合中元素的個數

         s.add();

         s.add(0,"");

         s.remove();

         s.remove(1,"");

         新增和刪除的效率低,遍歷效率快

       LinkedList底層就是一個鏈表,有本身特有而父類沒有的方法

        有單鏈表和雙鏈表(含有前驅和後繼)之分

         LinkdeList lis=new LinkedList();

         新增和刪除的效率高,查詢效率低

    Set接口經常使用的實現類  散列表 Hash 以空間換時間

      存儲的都是惟一(不能夠重複),無序的數據   

               HashSet

         HashSet set = new HashSet();

         1.add新增數據

         2.實際上是使用了map.put(key,value)

         3.map.put(key,value)決定了key是惟一的

      兩個數據內容一致,Hash值確定一致

      Hash值一致,數據內容不必定相同

      比較步驟:1.比較Hash,

                 2.比較內存地址,

                 3.equals比較內容

    TreeSet  自帶排序 樹型結構

      只有實現Comparable接口的類才能被排序

    Map  單獨的接口

     keySet:全部key的集合

    HashMap 

    //使用for增強 遍歷keySet

    Set<String> keySet=map.keySet();

    for (String key : keySet) {

         System.out.print(key+" ");

     }

//使用Iterator遍歷

Set<String> keySet=map.keySet();

Iterator<String> iterator = keySet.iterator();//獲取迭代器對象

while(iterator.hasNext()){//證實集合中存在數據

String key = iterator.next();

//根據key獲取value

String value=(String) map.get(key);

System.out.print(key+" "+value+" ");

}

//entry   Set<Map.Entry<k.v>> entrySet()

 

Set<Entry<String, Object>> entrySet = map.entrySet();
Iterator<Entry<String, Object>> iterator = entrySet.iterator();
while(iterator.hasNext()){//證實集合中存在數據
Entry<String, Object> entry = iterator.next();
System.out.println(entry.getKey()+"-------"+entry.getValue());
}

HashMap與HashTable的區別:

1.HashMap線程不安全,可是性能高

   HashTable線程安全,可是性能低

2.HashTable從1.0的版本就開始使用

   HashMap從1.2的版本就開始使用

3.HashMap底層就是Hash表來實現的  key和value均可以是null

   HashTablekey和value不能夠爲null   

Hashtable<String,String> table=new Hashtable<>();
table.put(null, null);//運行時異常

 

全部的集合中都有一個Iterator接口,用來遍歷集合中的數據,返回Iterator迭代器

   在Iterator接口中有三個方法:

    1.hasNext()  判斷集合中是否存在下一個元素,返回boolean類型

    2.next()     獲取集合中的下一個元素

    3.remove()   刪除元素

    

    TreeMap

泛型集合:在建立集合的時候,規定了集合中能存放的數據類型

List<String> lis=new ArrayList<String>();