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

亦凉 2021-12-03 07:53 386阅读 0赞

##### am #####

### List接口 ###

**特点：**

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

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

常用方法

![1639933-20190529084713893-1521069513.png][]

除了 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.堆栈结构  先进后出

![1639933-20190529090819637-1371900059.png][]

2 队列结构集合  先进先出

![1639933-20190529090929274-1780327782.png][]

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

![1639933-20190529091302156-1771181340.png][]

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

![1639933-20190529092110208-1860632514.png][]

###  LinkedList集合 ###

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

首尾常用操作方法

![1639933-20190529092454279-788485580.png][]

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常见方法：

![1639933-20190529094256779-1611344471.png][]

Enumeration 常用方法

![1639933-20190529094350697-843848945.png][]

## 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   不能存重复元素
            }
        }
    }

![1639933-20190529151608406-147918618.png][]

**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三个接口,存取元素时,有什么特点][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);
        }
    }

转载于:https://www.cnblogs.com/zs0322/p/10941923.html

[1639933-20190529084713893-1521069513.png]: /images/20211203/0ed9fbb19bb24a8aa5f7d9133d4a3e9a.png
[1639933-20190529090819637-1371900059.png]: /images/20211203/9b1b769648ed459fb99df5e78cc8fcea.png
[1639933-20190529090929274-1780327782.png]: /images/20211203/2adb31b84a09406fb88889b9585ddfa8.png
[1639933-20190529091302156-1771181340.png]: /images/20211203/04029eb2d6484183817adfc129e02d9c.png
[1639933-20190529092110208-1860632514.png]: /images/20211203/daf2187e922f4978841107f9bd5f7bdf.png
[1639933-20190529092454279-788485580.png]: /images/20211203/b9192530545b488d926ff03169c3c00a.png
[1639933-20190529094256779-1611344471.png]: /images/20211203/de60805cb5e2496181d51128b605c369.png
[1639933-20190529094350697-843848945.png]: /images/20211203/8286799196e9452ab7e595351ce4c126.png
[1639933-20190529151608406-147918618.png]: /images/20211203/2760f4987b4e4ecc86c60d26ea42b255.png
[List_Set]: https://www.cnblogs.com/areyouready/p/7580489.html