您的位置:首页 > 编程语言 > Java开发

JAVA--高级基础开发

2019-11-15 12:04 1751 查看

day04【List、Set、数据结构、Collections】

  • List 集合
  1. 我们在前面学习了Colllection 接口的使用,下面就来学习Collection 子接口的实现类以及子接口中特有的方法。 List接口的介绍
  • List接口位于Java.util.List包中。它继承自Collection.是Collection接口的一个子集,我们通常会将实现List接口的对象叫做List集合。那么在List集合中,允许出现重复的元素,并且元素是有顺序排列的。即元素的存入顺序和取出的顺序一致。
  • List集合的特点:
    1. 它是一个元素存取有序的集合。
    2. 它是一个带有索引的集合, 凡是存储到List集合中的元素,都带有一个索引,并且默认下标从0开始。
    3. 它里面可以有重复的元素,并且通过equals方法来进行比较是否有重复的元素。

     List接口中常用的方法

    1. List 集合是Collection 集合的子接口,它不但继承了Collection接口中全部的方法,而且还增加了一些根据元素索引来操作List 集合的方法。
    1. boolean  add(E e) ;将指定的元素追加到此列表的末尾(可选操作)。
    2. void  add(int index, E element);将指定的元素添加到集合中指定的位置。
    3. boolean addAll(int index, Collection<? extends E> c) ;将指定集合中的所有元素插入到此列表中的指定位置(可选操作)。 
    4. public  E get(int index):返回集合中指定位置的元素。
    5. public E remove(int index):移除指定位置上的元素,并返回被移除的元素
    6. public E set(int index, E element);用指定的元素,替换此列表中指定位置的元素。返回替换后的结果。

    /List集合的使用

    public class Test11 {

        public static void main(String[] args) {

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

            list.add("王智雅");

            list.add("杨寅喆");

            list.add("马士甜");

            list.add("刘亚晴");

            list.add("李文杰");

            //给集合中指定的位置添加指定的元素

            list.add(0,"李文杰");

            //将集合中的元素指定索引添加到另一盒集合中

            ArrayList<String> list2=new ArrayList<>();

            list2.addAll(0,list);

            //返回被移除的元素

            System.out.println(list.remove(3));

            //根据指定索引位置,替换值

            list2.set(0,"马超");

            // E get(int index):返回集合中指定位置的元素

            for(int i=0;i<list2.size();i++){

               System.out.println(list2.get(i));

            }

        }

    }

    • 数据结构

    2.1 常见的数据结构

    1. 常用的数据结构: 栈、 队列、数组、链表、红黑树。

    2.2  栈

    1. 栈: stack,又称为堆栈,它是运算受限的线性表,其限制是仅允许在标的一段插入和删除操作,不允许在其他任何位置进行添加,删除,查找。
    2. 简单的来说,采用该结构的集合,对元素的存取有以下的特点:
    • 先进后出(例如:子弹压进弹夹,先压进去的子弹在下面,后压进去的子弹在上面,当开枪时,先弹出上面的子弹,然后才能弹出下面的子弹。);
    • 栈的入口,出口,都是栈的顶端位置。
    1. 压栈:就是存元素,即,把元素存储到栈的顶端位置,栈中已有元素依次向栈低移动一个位置。
    2. 弹栈:就是取元素,即,把栈的顶端位置元素取出,栈中已有元素依次向栈顶移动一个位置
    3. 应用:List   LinkedList

    2.3  队列

    1. 队列:queue,简称队。它同堆栈一样,也是一种运算受限的线性表。其限制是仅允许在表的一端进行插入,在表的另一端进行删除。
    2. 简单的来说:采用这种结构的集合,对元素的存储有以下的特点:
    • 先进先出(类似于火车过山洞车头先进,车尾后进,车头先出,车尾后出)。
    • 队列的出口,入口各占一侧。
    • 应用:ArrayList

    2.4 链表

    1. 链表 LinkedList 有一系列的节点node(链表中的每一个元素称为一个节点) 组成。节点可以在运行的时候动态生成,每个节点包括两个部分:
    • 一种是存储数据元素的数据域。
    • 另一种是存储下一个节点地址的指针域。
    1. 我们通过所说的链表结构有单向的还有双向的,下面我们就介绍一下单向链表。
    2. 简单的来说:采用该结构的集合,有以下的特点:
    • 多个节点之间,通过地址进行连接,例如:多个人手拉手
    • 查找元素慢,想查找某个元素,需要通过连接的节点,依次向后查找指定的元素。
    • 增删元素快,只需要修改连接下个元素的地址即可。
    • 应用:LinkedList集合

    2.5  数组

    1. 数组:array 是有序的元素序列,数组是在内存中开辟一段连续的内存空间,并在此空间存放元素,就好比是一排房子,有 100 个房间,从 1-100 每个房间有固定编号,通过编号就可以快速找到房子。
    2. 简单的来说:采用该结构的集合,有以下的特点:
    • 查找元素快,通过索引,可以快速的找到指定位置上的元素。
    • 增删元素慢,指定索引位置增加元素,需要创建一个新的数组,将指定的新元素存储到指定的位置,在把原数组中的元素根据索引,复制到新数组对应的位置上。
    • 应用: ArrayList 集合

    2.6 红黑树

    1. 二叉树:binary tree 是每个结点不超过 2 的有序树。
    2. 简单的理解,就是类似我们生活中的一种树结构,且每个节点不超过2,顶上的叫根节点,两边的称为左子树和右子树。
    3. 我们说的二叉树的一种比较有意思的叫做红黑树,红黑树本身就是二叉树,也意味着,存放的数据必须是可排序的。
    • List接口的实现类

             List接口的实现类:ArrayList  和 LinkedList

    3.1 ArrayList 集合

    1. 位于java.util.ArrayList 包中。该集合存储的数据结构是数组的结构,元素的增删慢,查找快。由于日常中使用的最多的就是查找元素,遍历集合,所以ArrayList 最常用。

     

    //ArrayList集合的使用

    public class Test11 {

        public static void main(String[] args) {

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

            list.add("王智雅");

            list.add("杨寅喆");

            list.add("马士甜");

            list.add("刘亚晴");

            list.add("李文杰");

            //给集合中指定的位置添加指定的元素

            list.add(0,"李文杰");

            //将集合中的元素指定索引添加到另一盒集合中

            ArrayList<String> list2=new ArrayList<>();

            list2.addAll(0,list);

            //返回被移除的元素

            System.out.println(list.remove(3));

            //根据指定索引位置,替换值

            list2.set(0,"马超");

            // E get(int index):返回集合中指定位置的元素

            for(int i=0;i<list2.size();i++){

               System.out.println(list2.get(i));

            }

        }

    }

    3.2 LinkedList集合

    1. 位于java.util.LinkedList包中。LinkedList 集合存储的结构是链表结构。此集合查找元素慢,增删元素快。是一个双链表结构。既可以存储数据元素的数据域,还可以存储下一个节点地址的指针域。
    2. LinkedList集合常用的方法:
    • Public boolean add(E e);将指定的元素追加到此列表的末尾.
    • Public void add(int index, E element);在指定的索引位置上插入指定的元素。 
    • Public void addFirst(E e) ;在该列表开头插入指定的元素。
    • Public void addLast(E e) ;将指定的元素追加到此列表的末尾。
    • Public void addLast(E e);将指定的元素追加到此列表的末尾。 
    • Public  E get(int index);返回此列表中指定位置的元素
    • Public  E getFirst();返回此列表中的第一个元素。 
    • Public  E  getLast();返回此列表中的最后一个元素。 
    • Public  int indexOf(Object o); 返回此列表中指定元素的第一次出现的索引.
    • Public  int lastIndexOf(Object o);返回此列表集合中最后一次出现的索引。
    • Public  boolean offer(E e);将指定的元素添加为此列表的尾部(最后一个元素)。
    • Public boolean offerFirst(E e);在此列表的前面插入指定的元素。
    • Public  Object[] toArray(); 返回一个包含此列表中所有元素的数组。
    • public  E  pop():从此列表所表示的堆栈处弹出一个元素
    • public void push(E e):将元素压栈。

    /LinkedList集合的应用

    public class Test12 {

        public static void main(String[] args) {

            LinkedList<String>list=new LinkedList<>();

            list.add("liwenjie");

            list.add("wangzhiya");

            list.add("sangfengjiao");

            list.add("yangluhua");

            //int indexOf(Object o);返回此列表中指定元素的第一次出现的索引

            System.out.println(list.indexOf("liwenjie"));

            //E getFirst();返回此列表中的第一个元素。

            System.out.println(list.getFirst());

            //E getLast();返回此列表中的最后一个元素。

            System.out.println(list.getLast());

            //boolean offer(E e);将指定的元素添加为此列表的尾部(最后一个元素)。

            System.out.println(list.offer("马超"));

           //boolean offerFirst(E e);在此列表的前面插入指定的元素。

            System.out.println(list.offerFirst("李文杰"));

            //boolean offerLast(E e);在该列表的末尾插入指定的元素。

            System.out.println(list.offerLast("杨路华"));

            //Object[] toArray()以正确的顺序(从第一个到最后一个元素)

            // 返回一个包含此列表中所有元素的数组。

            Object[]arry=list.toArray();

            for(Object  ss:arry){

                System.out.println("=====>"+ss);

            }

            System.out.println("===================");

            //Linkedlist集合中的压栈 后进先出

            list.push("a");

            list.push("b");

            list.push("c");

            list.push("d");

            list.push("e");

            list.push("f");

     

            //LinkedList集合的弹栈 从栈顶弹出

            list.pop();

            list.pop();

     

            for(int  i=0;i<list.size();i++){

                System.out.print(list.get(i)+" ");

            }

     

        }

    }

    3.3 数字格式化 DecimalFormat

    • 位于java.text.DecimalFormat 包中,此类是根据十进制数格式化的一个类。
    • 格式化的规则:
    • 0 就代表一个数字。
    • # 号也代表一个数字,只不过#号对应位置上如果是0 就返回null.
    • .(点),小数的分隔符。
    • ,(逗号),数字位数的分隔符。
    • % 对应的就是当前位数的百分比。

    //DecimalFormat  数字的格式化

    public class DecimalFormats {

        public static void main(String[] args) {

            //数字的格式化

            DecimalFormat  ss=new DecimalFormat("0000.00");

            System.out.println(ss.format(4555.89));

            DecimalFormat  ss2=new DecimalFormat("####.##");

            System.out.println(ss2.format(2305.90));

            DecimalFormat  ss3=new DecimalFormat("0.##%");

            System.out.println(ss3.format(0.008));//0.8%

     

        }

    }

    • Set接口
    1. Set接口位于:java.util.Set 包中。也是继承了Collection 接口。它与Collection接口的方法一致,Set接口中的方法全部是来自Collection 接口中,
    2. Set接口的特点:
    • 元素的存储是无序的,并且不可以重复。
    1. Set集合的实现类:主要学习java.util.HashSet  和 java.util.LinkedHashSet

    4.1  HashSet集合

    1. HashSet是Set集合的实现类,实现Set接口,它遵循Set接口的特点。
    2. 特点: 无序不重复。

     

    //HashSet集合的特点:无序不重复-》示例

    public class Test13 {

        public static void main(String[] args) {

     

            //Set集合的特点无序不重复

            HashSet<String>set=new HashSet<>();

            set.add("liwnejie");

            set.add("wangziya");

            set.add("zhangsan");

            set.add("sangfenjiao");

            set.add("liwnejie");

            set.add("wangziya");

            System.out.println("不重复的长度:"+set.size());

     

            for(String  ss:set){

                System.out.println(ss);

            }

            //利用迭代器进行遍历集合

            Iterator<String> srf=set.iterator();

            while (srf.hasNext()){

                System.out.println(srf.next());

            }

     

            Object[]obj=set.toArray();

            for(Object  ss:obj){

                System.out.println("把set集合存入数组:"+ss);

            }

     

            HashSet<String>set1=new HashSet<>();

            set1.add("1234");

            set1.add("4567");

            set1.add("9876");

            set1.add("9765");

            set1.add("liwnejie");

            set1.add("wangziya");

            //运行的结果:无顺序,可以去掉重复的数

            // sangfenjiao

            // zhangsan

            // wangziya

            // liwnejie

        }

    }

    4.2 Set集合存储自定义类型的元素

    1. 如果Set 集合存储的是自定义类的元素,HashSet存放字自定义对象的时候,必须重写HashCode方法和equals方法,来实现相等规则的判断。

     

    1. 必须重写HashCode方法和equals方法,来实现相等规则的判断。

    @Override

        public boolean equals(Object o) {

            if (this == o) return true;

            if (!(o instanceof Student)) return false;

            Student student = (Student) o;

            return Objects.equals(name, student.name) &&

                    Objects.equals(age, student.age) &&

                    Objects.equals(sex, student.sex);

        }

     

        @Override

        public int hashCode() {

            return Objects.hash(name, age, sex);

    }

     

    //HashSet存放字自定义对象的时候,必须重写HashCode方法和equals方法

    public class Test14 {

        public static void main(String[] args) {

            HashSet<Student>set=new HashSet<>();

            set.add(new Student("张三",23,"大学"));

            set.add(new Student("张三",23,"大学"));

            set.add(new Student("张三",23,"大学"));

            set.add(new Student("张三",23,"大学"));

            set.add(new Student("张三",23,"大学"));

           //必须重写HashCode方法和equals方法,才能实现相等规则的判断,去掉重复的数字

            for(Student  ss:set){

                System.out.println(ss);

            }

            //如果两个对象相等,他们的Hashcode值一定相等,

            Student  ss=new Student();

            Student  ss2=ss;

            System.out.println(ss2.hashCode());

            System.out.println(ss.hashCode());

            //运行的结果: 29791 、29791

     

            // 如果两个对象的hashCode相等,那么这两个对象不一定相等。

            Teacher ss3=new Teacher();

            ss.setName("liwenjie");

            ss3.setName("liwenjie");

            System.out.println(ss.equals(ss3));//false

    }

    }

     

    1. HashSet存储数据的机制:Set集合在底层是通过Hash表来存储数据的。
    2. 如果两个对象相等,他们的Hashcode值一定相等,
    3. 如果两个对象的hashCode相等,那么这两个对象不一定相等。

    【在jdk1.8之前,哈希表底层采用数组+链表来实现,在jdk.8之后哈希表采用数组+链表+红黑树的结构来实现 ,其主要是做了性能的优化】

    4.3  LinkedHashSet

    1. LinkedHashSet 位于java.util.LinkedHashSet。
    2. LinkedHashSet 是HashSet 子类,它可以实现对存储的数据顺序的记录,并且按照所记录的顺序对元素进行输出。
    3. 特点:有序且不重复。

    //LinkedHashSet在Set集合中的作用主要是有序输出,去重复

     

    public class Test15 {

        public static void main(String[] args) {

            LinkedHashSet<String>list=new LinkedHashSet<>();

            list.add("李文杰");

            list.add("guoyanxin");

            list.add("wangzhiya");

            list.add("liwenjie");

            list.add("李文杰");

            //有序输出,去掉重复

            for(String  ss:list){

                System.out.println("有序的输出:"+ss);

            }

        }

    }

     

    4.4 Collections类[集合工具类]

    1. Collections 集合的工具类  位于java.util.Collections包中。其用来对集合进行操作。

    常用的方法:

    • static <T> boolean addAll(Collection<? super T> c, T... elements)将所有指定的元素添加到指定的集合。
    • static <T extends Comparable<? super T> void sort(List<T> list)此方法会自动升序排列
    • static void reverse(List<?> list) ;反转指定列表中元素的顺序。
    • static void shuffle(List<?> list);使用默认的随机源随机排列指定的列表。 

    //Collections 集合的工具类  位于java.util.Collections包中

    public class Test17 {

        public static void main(String[] args) {

            ArrayList<Integer>list=new ArrayList<>();

            //static <T> boolean addAll(Collection<? super T> c, T... elements)

            //将所有指定的元素添加到指定的集合。

            Collections.addAll(list,10,20,50,67,8,34,2,4);

            for(Integer  ss:list){

                System.out.println(ss);

            }

            ArrayList<String>list1=new ArrayList<>();

            Collections.addAll(list1,"liwenjie","wangzhiya","guoyanxing");

            for(String ss:list1){

                System.out.println(ss);

            }

            ArrayList<String>list2=new ArrayList<>();

            list2.add("r");

            list2.add("d");

            list2.add("a");

            list2.add("d");

            list2.add("b");

            //此方法会自动升序排列

           Collections.sort(list2);

            System.out.println(list2);

           //static void reverse(List<?> list)

            //反转指定列表中元素的顺序。

            Collections.reverse(list2);

            System.out.println(list2);

            //static void shuffle(List<?> list)随机排列

            //使用默认的随机源随机排列指定的列表。

            Collections.shuffle(list2);

            System.out.println(list2);

     

        }

    }

     

    4.5 可变参数

    1. 语法格式:可变参数,就是数据类型… 变量名,可以传递多个参数。

    可变参数的示例:

     

    //可变参数

    public class Test16 {

        public static void main(String[] args) {

            Meth("liwnejie","zhangsan","sangfengjiao","wangzhiya","lisi");

            Meth2(2,4,5,6,7,83,9,5,3,8);

        }

        //可变参数,就是数据类型... 变量名,可以传递多个参数

        public static  void  Meth(String... num){

            for(String  srf:num){

                System.out.println(srf);

            }

        }

        public  static void Meth2(int...a){

            for(int  ss:a){

                System.out.println(ss);

            }

        }

    }

     

    4.6 集合的总结

    1. Collection集合:是List集合和Set集合的父接口,它是可以重复,并且有序输出。
    2. List集合:它是可以重复,并且有序输出。【类似队列】,其子类有Arraylist和LinkedList
    3. ArrayList集合:是动态的数组,适合查找,不利于元素的增加删除。【类似数组】
    4. LinkedList集合:双向链表,指针域,数据域,【类型栈】,适合元素的增加删除,不利用于元素的查找。
    5. Set集合:它是无序不重复。主要的实现类有HashSet和LinkedHashSet.
    6. HashSet集合:特点:无序去重复。如果添加自定义的对象,必须重写HashCode方法和equals 方法。如果不重写,那么集合就可以重复。
    7. LinkedHashSet集合特点:有序不重复。

     

    内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
    标签: