其他分享
首页 > 其他分享> > day15_总结

day15_总结

作者：互联网

一 回顾

1.throw与 throws
  throws 声明一个异常   throw 抛出异常
2.自定义异常
    A.定义一个类 继承Execption
    B.调用父类构造方法 
3.在继承中异常: 子类重写的方法的异常声明 不能 超出父类的范围(父类异常声明本身或者是其子类)
4.集合:
   A.概念: 用于存储数据的容器
   B.集合与数组比较
      a.数组长度的固定的  集合的长度是可变的
      b.数组既可以存储引用数据类型  也可以存储基本数据类型  集合只能存储引用数据类型
   C.分类: 单列集合 与双列集合
   D.单列集合的接口 Collection
        boolean add(E e) 向集合的末尾添加数据
        void clear() 清空集合
        boolean contains(Object o) 判断集合中是否包含此元素
        boolean isEmpty() 判断集合是否为空
        Iterator<E> iterator()将集合转换为迭代器
        boolean remove(Object o) 删除集合中元素
        int size() 获取集合长度
        Object[] toArray() 将集合转换为数组
  F.List
       特点:
           有序 有索引  可以重复
       实现类: ArrayList  LinkedList
       方法:
         void add(int index,E element) 增加 
         E get(int index)查询
         E set(int index,E element) 修改
         E remove(int index) 删除
  G.集合的遍历方式:
       a.将集合转换为数组
       b.使用迭代器遍历
       c.使用增强for循环
       d.使用普通for循环（List以及实现类）

五 List

5.1 List-ListIterator

方法名称 方法描述
ListIterator listIterator() 将集合转换为迭代器
boolean hasPrevious() 判断是否有上一个元素
E previous() 返回列表中的前一个元素
void add(E e) 将指定的元素插入列表

代码

package com.qf.test02;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class Test01 {
    public static void main(String[] args) {
        //实例化集合
        List  li  = new ArrayList();
        li.add("贾玲");
        li.add("沈腾");
        li.add("宋小宝");
        li.add("马丽");
        //转换为迭代器
        ListIterator iter = li.listIterator();

         while (iter.hasNext()){
             iter.next();
         }
        //使用循环来遍历
        while (iter.hasPrevious()) {
            Object  obj =  iter.previous();
            System.out.println(obj);
        }

    }
}

5.2 并发异常-ConcurrentModificationException

问题: 使用迭代器遍历 使用集合的方法添加数据  集合修改数据之后 迭代器并不知道集合修改了数据
     所有就会产生并发异常
解决:
    A.使用迭代器遍历 使用迭代器添加数据
    B.使用集合传统的方式遍历 使用集合来添加数据

代码-问题

package com.qf.test02;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test02 {
    public static void main(String[] args) {
        //实例化集合
        List  li  = new ArrayList();
        //向集合中添加元素
        li.add("宋小宝");
        li.add("王胜龙");
        li.add("贾玲");
        li.add("阿飞");
        //将集合转换我迭代器
        Iterator iter = li.iterator();
        while (iter.hasNext()) {
            String s  = (String) iter.next();
            if (s.equals("王胜龙")) {
                li.add("小沈阳");
            }
        }

        System.out.println(li);
    }
}

解决-01

package com.qf.test02;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class Test03 {
    public static void main(String[] args) {
        //实例化集合
        List li  = new ArrayList();
        //向集合中添加元素
        li.add("宋小宝");
        li.add("王胜龙");
        li.add("贾玲");
        li.add("阿飞");
        //将集合转换为迭代器
        ListIterator iter = li.listIterator();
        //使用循环遍历
        while (iter.hasNext()) {
            String s  = (String) iter.next();
            if (s.equals("王胜龙")){
                iter.add("小沈阳");
            }
        }

        System.out.println(li);
    }
}

解决-02

package com.qf.test02;

import java.util.ArrayList;
import java.util.List;

public class Test04 {
    public static void main(String[] args) {
        //实例化集合
        List li  = new ArrayList();
        //向集合中添加元素
        li.add("宋小宝");
        li.add("王胜龙");
        li.add("贾玲");
        li.add("阿飞");
        //使用普通for循环
        for (int i=0;i<li.size();i++) {
            String s = (String) li.get(i);
            if (s.equals("王胜龙")) {
                li.add("小沈阳");
            }
        }

        System.out.println(li);
    }
}

六 ArrayList

6.1 简介

1.ArrayList是List接口的实现类
2.特点:
   A.ArrayList底层是以数组的数据结构  数组的初始化容量是10
      以数组数据结构存储特点: 查询快  增删慢   
   B.此实现不是同步的 在多线程中是不安全

6.2 数据结构-数组结构

image-20220729112325297

6.3 数据结构-栈结构

image-20220729112939584

6.4 数据结构-队列

image-20220729113413624

6.5 案例

step01 需求

image-20220729140937721

step02 分析

A.创建一个工人类  属性: 名称 年龄   工资 
B.实例化多个工人对象存入到集合
C.对集合进行操作

step03 代码-工人类

package com.qf.test03;

public class Worker {

    private  String name;
    private  int age;
    private  double sal;

    public Worker() {
    }

    public Worker(String name, int age, double sal) {
        this.name = name;
        this.age = age;
        this.sal = sal;
    }

    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;
    }

    public double getSal() {
        return sal;
    }

    public void setSal(double sal) {
        this.sal = sal;
    }

    @Override
    public String toString() {
        return "Worker{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sal=" + sal +
                '}';
    }
}

step04-测试类

package com.qf.test03;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;

public class Test01 {
    public static void main(String[] args) {
        //实例化集合
        List  list  = new ArrayList();
        //向集合中添加元素
        list.add(new Worker("胡大汉",18,10000));
        list.add(new Worker("小胡",20,12000));
        list.add(new Worker("阿飞",20,14000));
        list.add(new Worker("王胜龙",24,10000));
        list.add(new Worker("阿超",22,16000));
        list.add(new Worker("胡歌",40,18000));
        list.add(new Worker("小胡子",20,18000));
        //使用增强for循环打印工人的信息
        for (Object obj :list) {
            Worker w = (Worker) obj;
            System.out.println(w);
        }
        //使用循环获取每一个工人的工资
        double sum=0;
        Iterator iter = list.iterator();
        while (iter.hasNext()) {
            Worker w = (Worker) iter.next();
            sum+=w.getSal();
        }

        System.out.println((int)(sum/list.size()));

        //使用普通for循环
        for (int i=0;i<list.size();i++) {

           Worker w = (Worker) list.get(i);
           if (w.getName().contains("胡")){
               System.out.println(w);
           }
        }
        System.out.println("=======================");
        //使用循环遍历
        for (int i=0;i<list.size();i++) {
            //获取集合中对象
            Worker w = (Worker) list.get(i);
            if (w.getName().substring(0,1).equals("胡")){
                System.out.println(w);
            }
        }

        //实例化Scanner
        Scanner  input = new Scanner(System.in);
        System.out.println("请输入姓名");
        String name = input.next();
        //定义一个标记记录状态
        boolean flag  = false;
        //使用循环遍历集合 从集合中查找
        for (Object obj : list){
           Worker w = (Worker) obj;
           if (w.getName().equals(name)){
               System.out.println(w);
               flag = true;
               break;
           }
        }
        if (!flag){
            System.out.println("查无此人");
        }

        System.out.println("请输入工资");
        double  num = input.nextDouble();
        //使用循环遍历
        for (Object obj:list) {
             Worker w= (Worker) obj;
             if (w.getSal() > num) {
                 System.out.println(w);
             }
        }



    }
}

七 LinkedList

7.1 简介

1.LinkedList 也是List 接口的实现类
2.LinkedList是以链表的方式进行存储  数据结构-链表
3.特点:
    A.查询慢   增删快
    B.此实现不是同步的 在多线程中也是不安全的

7.2 独有的方法

方法的名称 方法的描述
public void addFirst(E e) 将指定元素插入此列表的开头
public void addLast(E e) 将指定元素添加到此列表的结尾
public E getFirst() 返回此列表的第一个元素
public E getLast() 返回此列表的最后一个元素
public E removeFirst() 移除并返回此列表的第一个元素。
public E removeLast() 移除并返回此列表的最后一个元素。

代码

package com.qf.test04;

import java.util.LinkedList;
import java.util.List;

public class Test01 {
    public static void main(String[] args) {
        //实例化集合
        LinkedList  li  = new LinkedList();
        //添加一个数据
        li.add("迪丽热巴");
        li.add("古力娜扎");
        System.out.println(li);
        //向集合头部增加元素
        li.addFirst("杨颖");
        li.addLast("杨幂");
        System.out.println(li);
        //获取集合头部与尾部的元素
        System.out.println(li.getFirst());
        System.out.println(li.getLast());
        //删除头部为尾部的元素
        li.removeFirst();
        System.out.println(li);
        li.removeLast();
        System.out.println(li);
    }
}

7.3 数据结构-链表

image-20220729152716916

7.4 案例

step01 验证ArrayList与LinkedList的效率(查询以及增加删除)

step02 分析

A.定义一个方法
B.根据毫秒值来判断其执行的效率

step03 代码

package com.qf.test05;

import java.util.ArrayList;
import java.util.LinkedList;

public class Test01 {
    public static void main(String[] args) {
//        addArrayList();
//        addLinkedList();
        selectArrayList();
        selectLinkedList();

    }

    public  static   void    addArrayList(){
        //实例化集合
        ArrayList list  = new ArrayList();
        //获取开始的毫秒值
        long startTime =System.currentTimeMillis();
        for (int i=0;i<100000000;i++) {
            list.add(i);
        }
        //获取结束的毫秒值
        long endTime =System.currentTimeMillis();
        System.out.println(endTime-startTime);
    }

    public static  void  addLinkedList(){
        //实例化LinekdList
        LinkedList list  = new LinkedList();

        long startTime =System.currentTimeMillis();
        for (int i=0;i<100000000;i++) {
            list.add(i);
        }
        //获取结束的毫秒值
        long endTime =System.currentTimeMillis();
        System.out.println(endTime-startTime);

    }

    public   static  void  selectArrayList(){

        ArrayList list  = new ArrayList();
        for (int i=0;i<10000000;i++) {
            list.add(i);
        }
        long startTime =System.currentTimeMillis();
        for (int i=0;i<list.size();i++) {
            list.get(i);
        }
        long endTime =System.currentTimeMillis();
        System.out.println(endTime-startTime);

    }

    public   static  void  selectLinkedList(){

        LinkedList list  = new LinkedList();
        for (int i=0;i<10000000;i++) {
            list.add(i);
        }
        long startTime =System.currentTimeMillis();
        for (int i=0;i<list.size();i++) {
            list.get(i);
        }
        long endTime =System.currentTimeMillis();
        System.out.println(endTime-startTime);

    }
}

八 Set

8.1 简介

1.Set集合是一个接口 实现类 HashSet TreeSet
2.特点:
    A.不能重复
    B.无序 没有索引 (存与取的顺序不一致)

代码

package com.qf.test06;

import java.util.HashSet;
import java.util.Set;

public class Test01 {
    public static void main(String[] args) {
        //实例化集合
        Set s  = new HashSet();
        //向集合中添加元素

         s.add("张三");
         s.add("迪丽热巴");
         s.add("李四");
         s.add("古力娜扎");
         s.add("阿飞");
         s.add("迪丽热巴");

        System.out.println(s);

    }
}

8.2 set集合的遍历方式

8.2.1 使用迭代器
package com.qf.test06;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class Test02 {
    public static void main(String[] args) {
        //实例集合
        Set s  = new HashSet();
        s.add("迪丽热巴");
        s.add("古力娜扎");
        s.add("渣渣辉");
        s.add("古天乐");
        //将集合转换为迭代器
        Iterator iter = s.iterator();
        while (iter.hasNext()) {
            System.out.println(iter.next());
        }
    }
}
8.2.2 使用增强for循环
package com.qf.test06;

import java.util.HashSet;
import java.util.Set;

public class Test03 {
    public static void main(String[] args) {
        Set s= new HashSet();
        s.add("迪丽热巴");
        s.add("古力娜扎");
        s.add("渣渣辉");
        s.add("古天乐");
        for (Object obj :s){
            System.out.println(obj);
        }
       
    }
}

8.3 案例

step01 需求

image-20220729162709035

step02 分析

A.产生一个20- 40   Math.random()*21+20
B.使用set集合来存储
C.使用while循环
     循环判断 条件:集合长度  <10

step03 代码

package com.qf.test06;

import java.util.HashSet;
import java.util.Set;

public class Test04 {
    public static void main(String[] args) {
        //实例化集合
        Set  s  = new HashSet();
        //使用循环给集合添加数据
        while (s.size() <10) {
            //产生随机数
            int  random = (int) (Math.random()*21+20);
            s.add(random);
        }

        System.out.println(s);
    }
}

标签：总结,li,util,day15,add,集合,import,public
来源： https://www.cnblogs.com/zhenglyz/p/16533459.html