JavaSE第三章 访问修饰符，Collection，List

一 访问修饰符

二 集合

数组，集合，都是对多个数据进行存储操作的，我们称之为容器
这里的存储是在内存层面进行存储的，而不是mybatis等持久化存储的方式（数据库）

1.1 数组

• 数组一旦指明了长度，那么长度就被确定了，不可更改

int [] arr=new int[6]

• 数组只能存储一种类型的数据

int  []arr,String[]s

缺点

• 长度不可变
• 删除增加元素效率低
• 其中存的元素有序，用下标确定顺序

1.2 集合

不同集合的底层结构不一样

集合分为两块Collection和Map

//集合有一个特点：只能存放引用数据类型的数据，不能是基本数据类型
//基本数据类型自动装箱，对应包装类。int--->Integer

• 存储一个个的存数据，List
  主要是Collection接口，底下有两个子接口，继承了这个Collection接口的一些特性，List子接口implements两个实现类，分别是ArrayList和LinkedList，ArrayList的底层是Object类型的数组，所以可以放多种数据
• 一对一对的存数据， Map
  Map底下两个实现类，HashMap和TreeMap
  集合的应用场合
  前端点击发送请求到后端，后端把实现逻辑，做成一个请求的事件，给数据库，数据库再把符合实现逻辑的信息，封装成一个数据包，发给后端，再被前端读取

1.3 读Collection的源码

主要包括增删改查判断五个部分

1.3.1 add添加方法

public class Test01 {
    public static void main(String[] args) {
        Collection col=new ArrayList<>();
        col.add(18);
        col.add(12);
        col.add(11);
        col.add(17);
        System.out.println(col);
    }
}

1.3.2 clear，size，isEmpty方法

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;

public class Test01 {
    public static void main(String[] args) {
        Collection col=new ArrayList<>();
        col.add(18);
        col.add(12);
        col.add(11);
        col.add(17);
        System.out.println(col);
        List list= Arrays.asList(new Integer[]{11,15,3,7,1});
        col.addAll(list);//将另一个集合添加到col中去
        System.out.println(col);
        col.clear();//清空集合的全部内容
        System.out.println(col);
        System.out.println("集合判空操作："+col.isEmpty());
        System.out.println("判断集合长度："+col.size());

    }
}

1.3.3 remove 方法

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;

public class Test01 {
    public static void main(String[] args) {
        Collection col=new ArrayList<>();
        col.add(18);
        col.add(12);
        col.add(11);
        col.add(17);
        System.out.println(col);
        List list= Arrays.asList(new Integer[]{11,15,3,7,1});
        col.addAll(list);//将另一个集合添加到col中去
        System.out.println(col);
        //col.clear();//清空集合的全部内容
        System.out.println(col);
        System.out.println("集合判空操作："+col.isEmpty());
        System.out.println("判断集合长度："+col.size());
        System.out.println("去除集合中指定元素："+col.remove(15));

    }
}

1.3.4 equals方法与contain方法

import java.util.ArrayList;
import java.util.Collection;

public class Test02 {
    public static void main(String[] args) {
        Collection col1=new ArrayList<>();
        col1.add(1);
        col1.add(2);
        Collection col2=new ArrayList<>();
        col2.add(1);
        col2.add(2);
        System.out.println(col2.equals(col1));
        System.out.println(col2.contains(3));
    }
}

1.3.5 遍历，迭代器或者增强for循环

hasnext,有没有下一个元素，有就返回true,没有就返回false
next方法，把指针下移

package com.xyt.test01;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.Objects;

public class Test03 {
    public static void main(String[] args) {
        Collection collection=new ArrayList<>();
        collection.add(18);
        collection.add(12);
        collection.add(11);
        collection.add(17);
        //对集合遍历，普通for循环,获取不到元素
      /* for (int i = 0; i < collection.size(); i++) {
            collection.
        }
       */
        //增强for循环
        for (Object o:collection){
            System.out.println(o);
        }
        //方式三
        Iterator it = collection.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

1.3.6 迭代器重点

package com.xyt.test01;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Test04 {
    //这是main方法，程序的入口
    public static void main(String[] args) {
        Collection collection=new ArrayList();
        collection.add(88);
        collection.add(89);
        collection.add(100);
        collection.add(101);
        Iterator iterator= collection.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

1.4 List

子接口继承自父collection接口

1.4.1 List的增删改查操作

面试题：List遍历方式有三种，foreach ,itreactor迭代器，下标遍历

package com.xyt.test02;

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

public class Test01 {
    public static void main(String[] args) {
        /**
         * List接口的常用方法
         * add,remove,set,get 增删改查
         */
        List list=new ArrayList<>();
        list.add(13);
        list.add(15);
        list.add(17);
        list.add(19);
        list.add("abc");
        System.out.println(list);
        // 放到下标为3的区域 [13, 15, 17, 66, 19, abc]，说明数组下标从0开始
        list.add(3,66);
        System.out.println(list);
        list.remove("abc");
        System.out.println(list);
        //[13, 15, 17, 66, 19]  按照元素名移除
        list.remove(2);
        // [13, 15, 66, 19] 按照下标移除
        System.out.println(list);
        list.set(3,67);
        System.out.println(list);
        // [13, 15, 17, 67, 19, abc]  说明下标为3的元素值被修改为了67

        Object o=list.get(0);
        System.out.println(o);
        // 13
        System.out.println("-------------------------------");
        //list集合。遍历的三种方式
        //方式一：普通下标遍历
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("--------------------------------");
        //方式二：增强for循环
        for (Object obj:
             list) {
            System.out.println(obj);
        }
        System.out.println("----------------------------------");
        //方式三：迭代器
        Iterator iterator= list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

1.4.2 实现一个电影票评分的统计

Movie类：

public class Movie {


    private String movieName;
    private double movieScore;
    private String movieActor;
    // 空参数构造器，相当于一个JavaBean对象，主要反射的应用
    public Movie() {

    }
    //movieActor是一个传过来的变量值，而this.movieActor是特指的内部变量名
    public Movie(String movieName,String movieActor,double movieScore){
        this.movieActor=movieActor;
        this.movieName=movieName;
        this.movieScore=movieScore;

    }
    public String getMovieName() {
        return movieName;
    }

    public void setMovieName(String movieName) {
        this.movieName = movieName;
    }
    public double getMovieScore() {
        return movieScore;
    }

    public void setMovieScore(double movieScore) {
        this.movieScore = movieScore;
    }

    public String getMovieActor() {
        return movieActor;
    }

    public void setMovieActor(String movieActor) {
        this.movieActor = movieActor;
    }

    public Movie(String movieName) {
        this.movieName = movieName;
    }

}

测试类02：控制台输出

package com.xyt.test02;

import java.util.ArrayList;

public class Test02 {
    public static void main(String[] args) {
        ArrayList<Movie>  movies=new ArrayList<>();
        Movie aMovie=new Movie("肖申克的救赎","汤姆·克鲁斯",9.8);
        Movie bMovie=new Movie("让子弹飞","姜文",8.8);
        Movie cMovie=new Movie("1942","张国立",8.9);
       //把值赋给结构体链表中
        movies.add(aMovie);
        movies.add(bMovie);
        movies.add(cMovie);
        //依次读取元素的值
        for (int i = 0; i < movies.size(); i++) {
            Movie tMovie=movies.get(i);
            System.out.print("电影名字: "+tMovie.getMovieName());
            System.out.print("电影主角: "+tMovie.getMovieActor());
            System.out.print("电影评分: "+tMovie.getMovieScore());
            System.out.println();

        }



    }
}

测试类02结果

测试类03 JDBC链接数据库

测试类03结果

1.4.3 ArrayList实现类

源码类似于StringBuilder，底层用一个数组和一个count写的

在JDK1.7和JDK1.8里面。存在一定差距
1.7 数组长度初始化为10，扩容的时候扩展为原数组的1.5倍
1.8初始胡长度为空，调用构造器后才开始创造长度为10的数组
换JDK版本的方法

1.4.4 vector实现类

虽然vector已经被淘汰，底层Object数组
底层扩容2倍，带有sythorized关键字，线程安全
底层都是数组，查询效率高，缺点是删除增加麻烦

1.4.5 泛型

相当于数据分类的一种形式，比如说，按照下图所展示得ArrayList直接存，会出现问题，相当于做饭的调料都混在一起了

package com.xyt.test03;

import java.util.ArrayList;

public class Test01 {
    public static void main(String[] args) {
        ArrayList a1=new ArrayList<>();
        //录入成绩
        a1.add(98);
        a1.add(99);
        a1.add(100);
        a1.add(78);
        a1.add("谢意");
        for (Object obj:a1
             ) {
            System.out.println(obj);
        }
    }
}

加入泛型后，在编译时期，就会对这些编译对象进行检查，如果出错，类型就加入不进去
泛型就是<>里面的数据类型，这个类型在具体使用时候才会确定

ArrayList<Integer> al = new ArrayList<>();  --<>  ---钻石运算符

package com.xyt.test03;

import java.util.ArrayList;

public class Test01 {
    public static void main(String[] args) {
        ArrayList<Integer> a1=new ArrayList<Integer>();
        //录入成绩
        a1.add(98);
        a1.add(99);
        a1.add(100);
        a1.add(78);
       // a1.add("谢意");  会报错，防止数据浑水摸鱼，写到数据库里面去
        for (Integer in:a1
             ) {
            System.out.println(in);
        }
    }
}