List接口、集合存储数据结构、arraylist、linkedlist、vector集合、set接口、hashset集合、

am

List接口

特点：

①：有序集合（怎么存怎么取）  ②：有下标（每个元素插入位置精确控制）  ③：允许重复元素，equals方法比较是否重复元素

List接口的常用子类有：ArrayList集合、Linkedlist集合

常用方法

除了 add（E e）和 remove，其他都是list接口独有 带下标  

list主要就是带下标的方法

package com.oracle.demo01;
import java.util.ArrayList;
import java.util.List;
public class Demo01 {
    public static void main(String[] args) {
        //创建list接口
        List<String> list=new ArrayList<String>();
        list.add("123");
        list.add("abc");
        //指定位置插入指定元素
        list.add(1,"456");
        //删除指定位置上的元素
        String s=list.remove(1);
        System.out.println("删除元素为"+s);
        //替换指定位置上的元素
        String str=list.set(0,"小猪佩奇");
        System.out.println("替换的元素为"+str);
        //遍历
        for(int i=0;i<list.size();i++){
            //在123 和abc之间插入456   
            System.out.println(list.get(i));
        }
    }
}

 Iterator的并发修改异常

 迭代器 增强for存在的意义： 遍历

 并发修改异常解决办法：在迭代时，不要使用集合的方法操作元素

package com.oracle.demo01;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Demo02 {
    public static void main(String[] args) {
        List<String> arr=new ArrayList<String>();
        arr.add("a");
        arr.add("b");
        arr.add("c");
        //在遍历时判断该集合中是否有"b"元素，如果有则在该位置添加一个"d"
        //获取迭代器对象
        Iterator<String> it=arr.iterator();
        while(it.hasNext()){
            String s=it.next();
            if(s.equals("b")){
                arr.add("d");
            }
        }
    }
}

 List集合存数据的结构

 1.堆栈结构  先进后出

2 队列结构集合  先进先出

3 数组结构集合  因为有下标 查找快  增删慢

 

4 链表结构集合 ：查找慢因为没下标   增删快

 

 LinkedList集合

collection和list的子类  拥有它们的方法  存储 链表结构 方便添加删除 

首尾常用操作方法

package com.oracle.demo01;
//Linkedlist集合
import java.util.LinkedList;
public class Demo03 {
    public static void main(String[] args) {
　　　　//新建Linkedlist纯子类对象
        LinkedList<String> arr= new LinkedList<String>();
        //First谁在最后写 谁就是第一个  Last 自动往后堆加
        arr.addFirst("a");
        arr.addFirst("b");
        arr.addLast("c");
        arr.addLast("d");        
        //获取集合中第一个元素
        System.out.println("集合中第一个元素为"+arr.getFirst());
        //获取集合中最后一个元素
        System.out.println("集合中第一个元素为"+arr.getLast());
        //删除集合中第一个元素
        arr.removeFirst();
        //再删一个元素
        arr.removeFirst();
        //删除集合中最后一个元素
        arr.removeLast();
        //增强for遍历
            for(String s:arr){
                System.out.println(s);//bacd   
        }
        //判断集合里的元素是否为空
        if(!arr.isEmpty()){            //isEmpty 判断集合有没有元素
            System.out.println("该集合不为空");
        }
    }    
}

 Vector集合

 是jdk早期的集合，存储数组结构，独特的方式 就是枚举 Enumeration   早期的迭代器常见方法

Vector集合已被ArrayList集合替代    枚举 Enumeration已被迭代器 iterator替代

vector常见方法：

Enumeration 常用方法

 

pm

Set接口

接口及子类没有独有的方法，无下标  与collection接口的方法基本一样

学存储结构，学它为什么不能存重复元素

HashSet集合 是数组和链表的结合，无序

哈希表特点：

不能保证的迭代顺序与元素存储顺序相同

集合元素可以是null,但只能放入一个null

不是同步

采用哈希表存储数据，唯一性的方式依赖于：hashCode()与equals()方法

HashSet集合判断两个元素相等的标准是两个对象通过equals方法比较相等，并且两个对象的hashCode()方法返回值相等

package com.oracle.demo01;
import java.util.HashSet;
public class Demo04 {
    public static void main(String[] args) {
        //构造一个哈希set
        HashSet<String> set=new HashSet<String>();
        set.add("a");
        set.add("a");
        set.add("b");
        //遍历
        for(String s:set){
            System.out.println(s);//a b   不能存重复元素
        }
    }
}

String类的HashCode方法

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

package com.oracle.demo01;
public class Demo05 {
    public static void main(String[] args) {
        String a="abc";
        String b="abc";
        //调用hashCode方法
        System.out.println(a.hashCode());//96354 hashCode是obj的方法
        System.out.println(a.hashCode());
    }
}

------------------------------------------------
package com.oracle.demo01;

public class Person {
    private String name;
    private int age;
    //空参
    public Person(String name, int age) {
        super();
        //有参
        this.name = name;
        this.age = age;
    }
    //get set方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    @Override
    //哈希方法
    public int hashCode() {        
        return name.hashCode()+age;
    }
    @Override
    //equals方法
    public boolean equals(Object obj) {
        if(obj==this){
        return true;
        }
        if(obj instanceof Person){
            Person p=(Person)obj;
            //比内容 比年龄
            return this.name.equals(p.name)&&this.age==p.age;
        }
        return false;
    }
}
---------------------------------------------------
package com.oracle.demo01;
import java.util.HashSet;
public class Demo06 {
    public static void main(String[] args) {
        HashSet<Person> set=new HashSet<Person>();
        set.add(new Person("a",18));
        set.add(new Person("b",17));
        set.add(new Person("c",19));
        set.add(new Person("c",19));
        for(Person p:set){
            System.out.println(p);
        }
    }
}

HashSet不能存重复元素的原因

 快捷键：哈希方法和equals方法 

alt+shift+s  Generate hashCode()and equals()

LinkedHashSet

总结：List、Set三个接口,存取元素时,有什么特点

都是单列元素的集合，有一个共同的父接口Collection。

Set不允许有重复的元素，

存元素：add方法有boolean返回值，当集合中没有某个元素，add方法成功加入该元素时，返回true 当集合含有与某个元素equals相等的元素时，add方法无法加入该元素，返回false。

取元素：没法说取第几个，只能Iterator接口取得所有元素，再逐一遍历各个元素。

 

List有先后顺序的集合，

存元素：多次调用add(Object)方法时，每次加入的对象按先来后到的顺序排序，也可插队，调用add(int index,Object)方法，可以指定当前对象在集合中的存放位置。

取元素：方法1：Iterator接口取得所有，逐一遍历各个元素

        方法2：调用get(index i)明确说明取第几个。

LinkedHashSet和HashSet 区别：

linked是hashset的子类，比它功能多，可以保证元素怎么存和取

package com.oracle.demo01;
import java.util.LinkedHashSet;
public class Demo07 {
    public static void main(String[] args) {
        LinkedHashSet<String> set=new LinkedHashSet<String>();
        set.add("abc");
        set.add("aaa");
        set.add("bcd");
        set.add("abc");
        for(String s:set){
            System.out.println(s);
        }
    }
}

 判断集合元素唯一的原理

ArrayList的contains

 作业：

将"goOd gooD stUdy dAy dAy up"
         每个单词的首字母转换成大写其余还是小写字母(不许直接输出good good study day day up 要用代码实现)

package com.oracle.demo01;
public class zuoye {
    public static void main(String[] args) {
        /*将"goOd gooD stUdy dAy dAy up"
         每个单词的首字母转换成大写其余还是小写字母(不许直接输出good good study day day up 要用代码实现)*/
        String str="goOd gooD stUdy dAy dAy up";
        //步骤：把每个单词截取  正则表达式
        String[] strs=str.split(" ");
        StringBuffer buffer=new StringBuffer();
        //遍历6好元素
        for(int i=0;i<strs.length;i++){
            //所有字母都变小写
            String small=strs[i].toLowerCase();
            //截取首字母  substring
            String head=small.substring(0,1);
            //将字母转大写
            head=head.toUpperCase();
            //把首字母之后的字母取出来
            String body=small.substring(1);
            //拼接字符串
            buffer.append(head+body+" ");
        }
        String s=buffer.toString();
            System.out.println(s);
    }
}