zoukankan      html  css  js  c++  java
  • Java基础

    什么是Java?
        Java是一种编程语言,Java可以撰写跨平台应用软件,是由Sun 公司与1995年推出的程序设计语言和Java平台(JavaEE,JavaME,JavaSE)的总称。
    Java的历史
        2010年Oracle公司收购了Java。
    Java的体系
        JavaSE java平台标准版 桌面版
        JavaEE java平台企业版 大型网站
        JavaME java平台微型版 手机 移动终端
    Java的开发环境
        Eclipse、Myeclipse、InteliJ Idea、Jbuilder等等。
    Java程序的运行
        运行java需要在java虚拟机中,也叫做JVM,它是java运行环境的一部分,java运行环境又称为JRE。只要电脑中安装了JRE,就可以运行java程序。
     
    1.源文件:Java的源代码是.java结尾的文件。
    2.编译:然后通过编译器把源文件翻译成字节码文件,为.class文件
    3.运行:最后使用解释器来运行字节码文件。
     
    JDK是Java语言的开发包,可以将.java文件编译为可执行的Java程序。
    可执行Java程序需要JVM才可以运行。 
    JRE(运行环境)包含了JVM(虚拟机)。
    JDK包含了JRE
     
    什么是JRE?
     JRE(Java Runtime Environment,java运行环境),运行Java程序所需要的环境集合,包含了JVM标准实现及Java核心类库,仅能够完成java的运行,无法对java进行编译、调试等。
     
    什么是JDK?
    JDK(Java Development Kit)是Java语言的软件开发工具包(SDK),是面向Java开发者发布的Java套件。
    JDK包含的基本组件包括:编译器、Jar打包工具、Javadoc文档生成器、Debug调试器、头文件生成器、反汇编器、监控工具等。
    JDK中包含完整的JRE
     
    InteiliJ IDEA 
    安装Idea、可添加插件->Preferences->Plugins->Install
    常用插件:
    activate-power-mode 打字轰炸效果
    CodeGlance 类似minimap 右边小地图
    IDEA快捷键:
    option+command+L 代码格式化
    注视 command+/
    导入包 option+回车
    移动代码行 command+shift+上下
    进入类 command+左键点击
     
     
    调试:
    F7、F8 下一步
     
    检查是否安装java
    打开终端 输入 java -version 如果安装了会提示当前安装的版本 如果没安装需要安装https://java.com/zh_CN/
     
    然后安装 java jdk
     
    项目结构
    src项目源文件 com.xxx.baidawei 每一个.一个文件夹
    Libraries 引用的包文件
     
    注视:  //单行 /**/ 多行 文档注视/** */
    关键字:Java中的关键字均为小写,如 class void static public等等。
     
    变量 可变的量 为内存中的数据起别名
    常量 不可变的量 
    数据类型:
        基本数据类型:整数(byte 、short、int、long)、小数(float、double)、字符(char)、布尔(boolean)
            Java中默认的整数类型是int类型,如果定义long需要后面加一个L。
            Java中默认的浮点类型是double类型,如果定义为float类型后面需要加一个F。
        引用数据类型:字符串(String)、数组、类、接口
    定义变量 类型 变量1,变量2,变量n
    byte score; int sumScore;long fileSize; float x,y; short age; double result; char sex;boolean isa; String name;大写的string
    变量的初始化
    age=23;score = 70+5;i=10/5;result=3.5;sex=‘男’;isa = true;name=‘张飞’;
    变量的命名规则:首字母是 英文字母、$或下划线,由字母数字、下划线组成,尽量有意义如sex,在java中变量首字母小写 与类名、接口名区分,驼峰命名法,sumSore。
    变量作用域
    大括号作为语句块的范围,称为作用域。作用域中变量不能重复定义。离开作用域变量所分配的内存会被JVM回收。
     
    数据类型转换:
    byte -> short -> int ->long -> float -> double 
    1.自动转换 范围小的可以直接转换为范围大的。  
    2.强制转换 范围大的转换为范围小的。 int a12 = (int)a11;
     
     
    运算符:
    算数运算符:
    +、-、*、/、%、 加减乘除取余
    自增、自减、自乘、自除;
    int+=1;int=int+1; int-=1; int = int - 1;
    ++I;先加 i++; 先运算后++;
     
    赋值运算符:
    = 把右边的值赋值给左边的变量;
     
    比较运算符:
    >、<、>=、<=、!=、==  大于、小于、大于等于、小于等于、不等于、等于
     
    逻辑运算符:
    & 与 两边都为true 结果为true
    | 或 有一遍为true 结果为true
    ^ 异或 true ^ false 结果True 两边相同为false
    !  非 取反 不为true 结果为true
    && 短路与 一边是false ,另一边不运行 效率高于一个的
    || 短路或 一边是true,另一边不运行 效率高于一个的
     
    三元运算符:
    (布尔表达式) ? (真结果1) : (假结果2)    3>1?’big’:’small’;
     
    Scanner类
    在命令行中接受键盘输入
    1.引入包 import java.util.Scanner;
    2.实例化 Scanner sc = new Scanner(System.in);
    3.使用方法 sc.nextInt(); 接受输入的整数 sc.next();接受输入的字符串
     
    Random类
    产生随机数
    1.引入包 import java.util.Random;
    2.实例化 Random  r = new Random();
    3.使用 r.nextInt(99); //范围 生成一个随机数
     
    流程控制语句
    IF语句 如果满足某个条件 就执行 
        If(1==1 || 2 ==2){
        }else if(1 != 1 && 1 != 3){
        }else{
        }
    Swtich语句 
        switch(a){
            Case 1:
            case 2:
            Break;
             Default:
            Break;
        }
     
    循环语句
    while循环 先判断再循环 条件为真就循环
    While(I<5){
        I++;
    }
     
    do..while循环 先执行再判断
    do{
    }while(true);
     
    for循环  
    指定次数的循环
    for(int I = 1;i<10;i++){
    }
     
    break语句
    停止循环
     
    continue语句
    结束本次,继续下次循环。
     
    数组:
    数据类型[] 数组名 = new 数据类型[元素个数];
    下标从0开始,最大值长度-1.超出报错。
    int [] nums = new int[3];
    nums[2] = 1;
     
    //定义的同时对数据进行赋值
    int[] arr = new int[]{1,2,3,4,4};
    int[] arr= {1,2,3,4,5}; //简化版
     
    //遍历数组
    for(int I= 0;i<arr.length;i++){
        System.out.println(arr[i]);
    }
     
    二维数组:
    //二维数组中有三个一纬数组
    //三个一纬数组的长度是四
    int[][] arrs = new int[3][4];
    arrs[0][0] = 1;
    System.out.println(arrs[0][0]);
     
    int[][] arrs = {{1,2,3,4,5},{1,2,3,4,5}};
    for(int i = 0;i<arrs.length;i++){
        for(int j = 0;j<arrs[i].length;j++){
            System.out.println(arrs[i][j]);
        }
    }
     
    方法:
    修饰符 返回值类型 方法名(参数1,参数2,……){
        return 返回值;
    }
    返回值的结果要与返回类型一致。
    public static void main(String[] args) {
        System.out.println(sayHi());
    }
    public static String sayHi(){
        return "Hi";
    }
     
     
    方法的重载:
    在同一个类中,方法名一致,参数列表不同即可。
    public static void main(String[] args) {
        System.out.println(sayHi("david"));
    }
    public static String sayHi(){
        return "Hi";
    }
    public static String sayHi(String name){
        return name + "Hi";
    }
     
    方法中参数是基本数据类型:
    方法内改变值不影响原值。
     
    方法中参数是引用数据类型:
    方法内改变值影响原值。
     
    类:
    public class 类名{
        属性定义
            修饰符 数据类型 = 值;
        方法定义
            修饰符 返回值类型 方法名(参数列表){
            }
    }
     
    public class Phone {
        public int Size = 14;
        public String Color = "Red";
        public String Call(String number){
            return "正在呼叫:"+number;
        }
    }
     
    public static void main(String[] args) {
        Phone p = new Phone();
        System.out.print(p.Call("13845054318"));
        p.Size = 100;
        System.out.print(p.Size);
    }
     
     
    ArrayList集合
    1.导入包 import java.util.ArrayList;
    2.创建对象 ArrayList<数据类型> 名 = new ArrayList<数据类型>();
    数据类型不能是基本数据类型,必须是引用数据类型。
    byte -> Byte
    short -> Short
    Int -> Integer
    long -> Long
    float -> Float
    double -> Double
    char -> Character
    boolean -> Boolean
     
    常用方法:
    Add() 添加元素
    Get() 取出元素 索引取出
    size() 返回长度 
    Set() 修改指定索引的元素
    remove() 移除指定索引的元素
    Clear() 清空
     
    ArrayList<Integer> nums = new ArrayList<Integer>();
    nums.add(1);
    nums.add(3);
    nums.add(3);
    nums.add(3);
    nums.add(3);
    for(int i = 0;i<nums.size();i++){
        System.out.println(nums.get(i));
    }
     
    面向对象
    三大特性:封装、集成、多态。
     
    封装:隐藏具体实现的细节,对外提供可以访问的方式。便于调用者的使用。提高了复用性。
     
    private 私有的 
    get、set方法
    public class Phone {
        private int size;
        public void setSize(int s){
            size = s;
        }
        public int getSize(){
            return size;
        }
    }
     
    this关键字
        区分成员变量和局部变量同名的情况
    this.size为属性 
    public class Phone {
        private int size;
        public void setSize(int s){
            int size = 1;
            this.size = s;
        }
        public int getSize(){
            return this.size;
        }
    }
     
    继承:子类自动拥有父类所有可继承的属性和方法。
    class 子类 extends 父类{}
    单继承,一个类只可以有一个父类
    方法重写:子类方法名与父类一致,参数也一致。调用时如果子类有就调用子类的没有再调用父类的。
     
    抽象类:
    public abstract 返回值类型 方法名(参数){}
    抽象类不能被创建对象,因为抽象方法没有意义。
    抽象类一定是个父类,如果没有子类重写他的方法,那么他将没有意义。
    public abstract class Phone {
        //抽象函数 没有方法体
        public abstract void Call();
    }
    public abstract class Iphone extends Phone {
        public void Work(){
            System.out.println("abstract");
        }
    }
     
    接口:
    接口最主要的是用来解决多继承的弊端,将多继承这种机制在java中通过实现完成了。
    public interface 接口名{
        抽象方法1;
        抽象方法2;
    }
    接口中的方法不能有方法体,属性必须为常量。方法可以不写public abstract
    public interface Iphone{
        //常量
        public static final int Age = 18;
        //抽象方法
        public abstract void SayHi();
    }
    实现一个接口使用关键字implements,并且实现接口的全部方法。
    public class Phone implements Iphone{
        public void SayHi(){
            System.out.print("接口"+ this.Age);
        }
    }
    多实现:
    A implements  B,C
     
    在一个类中可以同时继承并且实现多个接口
    A extends B implements C,D
     
    多态:
    对象在调用同一个方法时表现出来的多种状态。
    如:你在vs中按f1出现vs的帮助文档,在idea中按f1则会出现idea的使用帮助。
     
    多态的三个必要条件:继承、重写、父类引用指向子类对象
     
    父类类型或者接口类型  变量 = new 子类的对象();
    Person p1 = new Student();
    Person p2 = new Teacher();
     
    instanceof关键字
    比较运算符,返回真假,判断某个对象是否属于某种数据类型。
    boolean result = 对象 instanceof 数据类型;
     
    P1 instanceof Student(); //true
    p2 instanceof Student(); //false
     
    转型
    向上转型:当有子类对象复制给一个负累引用时,就是向上转型,多态本身就是向上转型的过程。
    向下转型:将负累引用转换为子类引用。强制转换。
    Student stu =(person) p1;
     
    构造方法:
    创建对象时,初始化对象。 构造方法没有返回值类型。
    如果没有自定义构造函数,系统会有一个默认无参的构造函数。
    public class Person {
        private String name;
        private int age;
     
        Person(String name,int age){
            this.name = name;
            this.age = age;
        }
     
        public void SayHi(){
            System.out.println("我叫:"+this.name+";我今年:"+this.age+"岁了");
        }
     
    }
     
    public static void main(String[] args) {
        Person p = new Person("david",18);
        p.SayHi();
    }
     
    this关键字
    可以在多个构造方法之间调用
    public class Person {
        private String name;
        private int age;
     
        Person(String name){
            this.name = name;
        }
     
        Person(String name,int age){
            this(name);
            this.age = age;
        }
     
        public void SayHi(){
            System.out.println("我叫:"+this.name+";我今年:"+this.age+"岁了");
        }
     
    }
     
    super关键字
    在创建子类对象时,父类的构造方法会先执行,因为子类中所有构造方法的第一行有默认的隐式super();语句。
    使用super(实参列表) 可以调用父类中的构造方法。
    public class Chinese extends Person {
        Chinese(String name,int age){
            super(name,age);
        }
    }
    public class Main {
        public static void main(String[] args) {
            Chinese c = new Chinese("david",18);
            c.SayHi();
        }
    }
     
    final 不可变
    可以用来修饰类,类的成员,以及局部变量。
    final修饰的类 不可以被继承,但是可以继承其他类。
    final修饰的方法 不可以被子类重写。
    final修饰的变量 称为常量,不会改变的值。
     
    static 静态的
    静态的方法可以直接 类名.方法名调用 不需要实例化
    public class tai {
        public static void SayTai(){
            System.out.println("崩卡崩卡");
        }
    }
    tai.SayTai();
    静态不能调用非静态。
     
    匿名对象
    new person().say(); 只用一次
     
    内部类
    在一个类的内部定义一个类,成为内部类。
    内部类可以访问外部类所有成员,哪怕是私有的。
    // 外部类
    public class Outer {
        private String haha = "哈哈大笑";
        //内部类
        public class Inner{
            public void HAHA(){
                System.out.println(haha);
            }
        }
    }
     
    //访问方式 外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
    Outer.Inner inner = new Outer().new Inner();
    inner.HAHA();
     
     
    局部内部类
    方法中的内部类
    public void out(){
         class Inner{
            public void inner(){
                System.out.println("内部类方法");
            }
        }
        Inner in = new Inner();
         in.inner();
    }
    调用out()方法时,自动调用内部类中的方法
     
    匿名内部类
    new interface(){ //实例化接口 实现接口方法
        Public void smoking(){
        }
    }.smoking();
     
    java中的包,其实就是电脑中的文件夹,包中方的是类文件。
    命名规则,全部小写,域名反写、com.xxx.web
    package david.web; 包的声明 在第一行
    导入包
    import david.web.Outer; 具体到类名
     
    修饰符
    public、private、protected、default
    1.仅能在本类中使用 private
    2.本包中的类可以访问不加修饰符
    3.本包中的类与其他包中的子类可以访问 protected
    4.所有包中的所有类 public
    一个文件中只能有一个public修饰的类,如果用public修饰则类名必须与文件名相同。
     
    API
    java为我们封装好的一些类,直接使用即可。
     
    Object
    object是所有类的父类,object所有的方法,子类都能使用。
     
    equals
    比较两个对象是否相同。
     
    toString()
    返回该对象的字符串表示。
     
    String类
    字符串字面值是String其实是类的实例。
    字符串一旦创建,字符串本身不能改变,但str变量中记录的地址是可以改变的。
    String str = "abcdefghijklmnopq123456";
    String str2 = new String("abcdefghijklmnopq123456");
    System.out.println(str == str2); //false 引用类型数据,==比较的是对象的地址
    System.out.println(str.equals(str2)); //true equals 比较的是对象的内容
     
    常用方法:
    length()  返回字符串长度 字符个数
    substring(startIndex,endIndex) 截取字符串 返回从开始到结束的字符串
    startsWith(String prefix) 检测是否以此字符串开头
    endsWith(String suffix) 检测是否以此字符串结尾
    contains(String str) 判断字符串是否包含str字符串
    indexOf(String str) 返回制定字符串在字符串中第一次出现的索引 没有返回-1
    getBytes() 返回byte数组
    toCharArray() 返回字节数组
    equals(object obj) 字符串与指定对象比较
    equalsIgnoreCase() 比较字符串不考虑大小写
    toUpperCase() 转换大写
    toLowerCase() 转换小写
    replace() 替换字符串,使用的字符串
    Split() 参数分隔符 返回字符串数组
     
    StringBuffer类
    字符串缓冲区支持可变的字符串。
    StringBuffer sb = new StringBuffer();
    sb.append("开头"); //追加内容
    sb.append("中间");
    sb.insert(0,"在0插入");
    //"在0插入开头中间";
    sb.delete(1,4); //删除索引1到4的字符串
    //在开头中间
    sb.reverse(); //反转
    System.out.println(sb.toString());
    StringBuffer是线程安全的,所以速度慢一些。
    StringBuilder 不是线程安全的,所以比较快。
     
    正则表达式
    用来定义匹配规则,检查一个字符串是否符合该规则。
    \ 转义
    换行
    回车
    [abc] 范围abc中有一个即可
    [^abc] 取反 不能有abc中的一个
    [a-zA-Z] 小写a到z及大写A-Z中任何一个都可以
    [0-9] 匹配数字0到9之内
    [a-zA-Z_0-9] 匹配字母下划线数字
    预定义字符:
    d 相当于0-9
    w 相当于a-zA-Z
    ^ 代表的是行的开头
    $ 代表的是行的结尾
     单词边界
    ? 一次或一次也没有
    * 0次或多次
    + 一次或多次
    {n} 正好n次
    {n,} 至少n次
    {n,m} 至少n次,最多m次。
     
    字符串.matches(regex) 返回真假
    public static boolean checkQQ(String qq){
        boolean result = qq.matches("^[1-9][0-9]{4,9}$");
        return result;
    }
    邮箱验证
    String email = "abc123@sina.com.cn";
    boolean checkEmail = email.matches("[a-zA-Z0-9_]+@[a-zA-Z]+(\.[a-z]+)+");
    System.out.print(checkEmail);
     
    str.split(regex); 根据正则切割
    String str = "192.168.0.2";
    String[] strs = str.split("\.+");
    for(int i =0;i<strs.length;i++){
        System.out.println(strs[i]);
    }
     
    str.replaceAll(regex) 根据正则替换
    String str = "192.168.0.2";
    str = str.replaceAll("\.","*");
    System.out.print(str);
     
    Date类
    时间原点:公园1970年1月1日,午夜0点。 毫秒值是0;
    System.currentTimeMillis() 到今天的毫秒数
     
    import java.util.Date;
    Date date = new Date();
    date.getTime(); //返回当前毫秒值
    date.setTime(1521877860868L); //设置日期通过毫秒值
    System.out.print(date);
     
    日期格式化
    import java.text.SimpleDateFormat;
     
    SimpleDateFormat pattern = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    String date = pattern.format(new Date());
    System.out.println(date);
     
    字符串转成Date对象
    //有可能转换失败,所以要加异常。需要完全匹配规则
    public static void main(String[] args) throws ParseException {
        SimpleDateFormat pattern = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = pattern.parse("1995-12-1 12:12:12");
        System.out.println(date);
    }
     
    Calendar日历类
    抽象类,替换了很多Date中的方法。
    Calendar.getInstance(); 获取默认时区和语言环境获得一个日历。
     
    get() 方法 获取日历字段
    Calendar c = Calendar.getInstance();
    int year = c.get(Calendar.YEAR);
    int month = c.get(Calendar.MONTH)+1;
    int day = c.get(Calendar.DAY_OF_MONTH);
    System.out.println(year+"-"+month+"-"+day);
     
    Set() 方法 设置日历字段
    Calendar c = Calendar.getInstance();
    c.set(Calendar.YEAR,2088);
    c.set(2099,4,5);
    c.set(2099,4,5,12,30,0);
     
    add() 方法 
    c.add(Calendar.DATE,5); 添加5天
    c.add(Calendar.DATE,-5); 减少5天
     
    活了多少天
    Calendar my = Calendar.getInstance();
    Calendar c = Calendar.getInstance();
    my.set(1991,0,11);
    long day = c.getTimeInMillis();
    long myDay = my.getTimeInMillis();
    System.out.println((day-myDay)/1000/60/60/24);
     
    包装类
    包装类中封装了一些实用的方法和常量。
    Integer类 是int类型
    Integer.parseInt("123”); //将字符串转换为int类型
    Int转字符串
        int num = 10;
        System.out.println(num+""+12); //加双引号
    方法2:
        Integer.toString(num);
    常量两个:
    Integer.MAX_VALUE 最大值
    Integer.MIN_VALUE 最小值
     
    Byte类 是byte类型的包装类
    Float类 是float类型的包装类
     
    自动装箱:基本数据类型直接变成对象
    Integer i = 1; //Integer i = new Integer(1); 1转换成引用各类型 装箱
    自动拆箱:对象中的数据变回基本类型
    i++; //自动拆箱 引用类型会转换回基本类型做运算
     
    System类
    System.exit(0); //终止虚拟机jvm
    System.gc()
    ; //垃圾回收
    System.getProperties(); //获取系统信息
    System.arraycopy(); //复制数组
     
    Math类
    import java.lang.Math;
    Math.abs(-9)  绝对值
    Math.Max min 最大最小值
    Math.pow(a,b)a的b次方
    Math.random(); 随机数0.0-1.0之间
    Math.round(double d) 四舍五入,取整数 
     
    Arrays类
    import java.util.Arrays;
    Arrays.sort(arrys) 排序数组 升序
     
    Arrays.binarySearch(arrys,3) 查找值,返回出现的索引
     
    Arrays.toString(arrys) 输出字符串
     
    BigInteger类
    超大整型数据,比Long还大。
    import java.math.BigInteger;
    加法:
    BigInteger b1 = new BigInteger("1231231231231231233123");
    BigInteger b2 = new BigInteger("1231231231231231233123");
    System.out.println(b1.add(b2));
     
    减法:
    System.out.println(b1.subtract(b2));
     
    乘法:
    System.out.println(b1.multiply(b2));
     
    除法:
    System.out.println(b1.divide(b2));
     
    BigDecimal类
    高精度浮点运算
    import java.math.BigDecimal;
    //原因:计算机二进制中,表示浮点数不精确造成。
    System.out.println(0.09+0.01); //0.09999999999999999
    System.out.println(1.0-0.32); //0.6799999999999999
    System.out.println(1.015*100); //101.49999999999999
    System.out.println(1.301/100); //0.013009999999999999
     
    BigDecimal b1 = new BigDecimal("0.09");
    BigDecimal b2 = new BigDecimal("0.01");
    //加法
    System.out.println(b1.add(b2)); //0.10
    //减法
    System.out.println(b1.subtract(b2));//0.08
    //乘法
    System.out.println(b1.multiply(b2));//0.0009
    //除法 第二个参数保留几位小数,有可能除不尽的时候会报错
    System.out.println(b1.divide(b2,2));//9
     
    BigDecimal b3 = new BigDecimal("1.601");
    BigDecimal b4 = new BigDecimal("101");
    //ROUND_UP 向上+1  ROUND_DOWN 直接舍去 ROUND_HALF_UP四舍五入
    System.out.println(b3.divide(b4,4));//0.016
    System.out.println(b3.divide(b4,2,BigDecimal.ROUND_UP));//0.02
    System.out.println(b3.divide(b4,2,BigDecimal.ROUND_DOWN)); //0.01
    System.out.println(b3.divide(b4,2,BigDecimal.ROUND_HALF_UP)); //0.02
    System.out.println(b3.divide(b4,2,BigDecimal.ROUND_HALF_DOWN)); //0.02
     
    Collection接口
    是所有集合的根接口
    集合Collection接口中的方法(所有实现类必须拥有的方法)。
    //接口多态的方式调用
    Collection<String> co = new ArrayList<String>();
    //添加元素
    co.add("abc");
    co.add("bcd");
    System.out.println(co);//[abc, bcd]
    //清空集合中的元素
    co.clear();
    System.out.println(co);//[]
     
    contains(object o) 判断对象是否存在于集合中,存在返回true。
    co.contains("abc”);
     
    toArray(); 将集合转成数组
    Object[] obj = co.toArray();
    for(int i = 0;i<obj.length;i++){
        System.out.println(obj[i]);
    }
     
    remove(); 删除
    co.remove("abc”); //删除第一个匹配的元素
     
    Iterator接口 迭代器
    Java中提供了许多集合,他们在存储时方式不同。取出时通过一种通用的方式。如果有就取出。
    接口Iterator :两个抽象方法
        boolean hasNext() 判断集合中还有没有可以被取出的元素,如果有返回true。
        next() 取出集合中的下一个元素
    使用ArrayList集合的对象
        Iterator it = array.iterator(); 运行结果就是Iterator接口的实现类对象
        It是接口的实现类对象,调用方法hasNext和next集合元素迭代
     
    Collection<String> co = new ArrayList<String>();
    co.add("abc");
    co.add("bcd");
    co.add("abc");
    Iterator<String> it = co.iterator();
    while(it.hasNext()){
        String val = it.next();
        System.out.println(val);
    }
     
    for写法
    for(Iterator<String> it = co.iterator();it.hasNext();){
        System.out.println(it.next());
    }
     
    增强for循环
    Jdk1.5以后出来的新特性,java.lang.Iterable。
    collection(原集合根接口)开始继承Iterable。
    格式:
        for(数据类型 变量名 : 数组或集合){
            System.out.println(变量名);
        }
    int[] nums = {1,2,3,4,5,6,6,6,6,4,3,2,23,4};
    for(int n : nums){
        System.out.println(n);
    }
    好处:代码少,方便遍历
    弊端:没有索引,不能操作容器里面的元素
     
    泛型
    使用集合时,明确集合中的元素类型。不会像arrayList那样object强转异常。
     Collection<String> coll = new ArrayList<String>();
     
    Java泛型是伪泛型
    ArrayList<String> 编译手段
    arr.add(“”) 不是String的时候编译失败
    但是编译后的class文件,是没有泛型的
     
          修饰符 class 类名<代表泛型的变量> {  }
          例如,API中的ArrayList集合:
          class ArrayList<E>{
               public boolean add(E e){ }
            public E get(int index){  }
          }
     
          创建对象时,确定泛型的类型
          例如,ArrayList<String> list = new ArrayList<String>();
          此时,变量E的值就是String类型
          class ArrayList<String>{
            public boolean add(String e){ }
            public String get(int index){  }
          }
          例如,ArrayList<Integer> list = new ArrayList<Integer>();
          此时,变量E的值就是Integer类型
          class ArrayList<Integer>{
               public boolean add(Integer e){ }
               public Integer get(int index){  }
          }
     
    ?泛型的通配符
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
     
    public class Main {
        public static void main(String[] args){
            ArrayList<Integer> nums = new ArrayList<Integer>();
            nums.add(1);
            nums.add(2);
     
            ArrayList<String> strs = new ArrayList<String>();
            strs.add("abc");
            strs.add("def");
     
            iterator(nums);
            iterator(strs);
     
        }
        public static void iterator(Collection<?> coll){
            Iterator<?> it = coll.iterator();
            while(it.hasNext()){
                System.out.println(it.next());
            }
        }
    }
     
    泛型的限定
          //创建3个集合对象
          ArrayList<ChuShi> cs = new ArrayList<ChuShi>();
          ArrayList<FuWuYuan> fwy = new ArrayList<FuWuYuan>();
          ArrayList<JingLi> jl = new ArrayList<JingLi>();
          //每个集合存储自己的元素
          cs.add(new ChuShi("张三", "后厨001"));
          cs.add(new ChuShi("李四", "后厨002"));
          fwy.add(new FuWuYuan("翠花", "服务部001"));
          fwy.add(new FuWuYuan("酸菜", "服务部002"));
          jl.add(new JingLi("小名", "董事会001", 123456789.32));
          jl.add(new JingLi("小强", "董事会002", 123456789.33));
          iterator(jl);
          iterator(fwy);
          iterator(cs);
     
    //方法参数: 控制,可以传递Employee对象,也可以传递Employee的子类的对象
        public static void iterator(ArrayList<? extends Employee> array){
           Iterator<? extends Employee> it = array.iterator();
           while(it.hasNext()){
             //获取出的next() 数据类型,是什么Employee
             Employee e = it.next();
             e.work();
           }
        }
     
    List接口
    有序的collection,可以对每个元素的插入位置进行精确的控制,根据整数索引控制。
    可以存储重复元素。
    继承Collection接口,实现类ArrayList、LinkedList。
     
    并发修改异常
    使用迭代器遍历集合时改变集合会报错。
    Iterator<String> it = co.iterator();
    while(it.hasNext()){
        String val = it.next();
        if(val==“abc”)
           Co.add(“aa”); //迭代器工作时 不可以改变集合
        System.out.println(val);
    }
     
    LinkedList类 
    import java.util.LinkedList;
    对一个集合的操作如果大多是首尾操作那么推荐使用LinkedList类。
    LinkedList<Integer> link = new LinkedList<Integer>();
    link.add(1);
    link.addLast(2);//添加到当前末尾
    link.add(3);
    link.addFirst(4); //添加到当前开头
    if(!link.isEmpty()){ //link.size() != 0
        System.out.println(link); //[4, 1, 2, 3]
        System.out.println(link.getFirst()); //获取开头
        System.out.println(link.getLast()); //获取结尾
    }
    link.removeFirst();
    link.removeLast();
    System.out.println(link);//[1, 2]
     
    Set接口
    不允许存储重复元素,取出可以使用迭代器、增强for。没有索引,无序的。
    继承collection,实现类hashSet。
    HashSet<String> set = new HashSet<String>();
    set.add("haha1");
    set.add("abc2");
    set.add("def3");
    set.add("ghi4");
     
    for(String s : set){
        System.out.println(s);
    }
    如果存入重复的,只存进去一个。
     
    Map接口
    键值对集合,不能重复key,常用集合为HashMap集合、LinkedHashMap集合。
    HashMap<Integer,String> map = new HashMap<Integer,String>();
    //添加键值对
    map.put(1,"a");
    map.put(2,"b");
    map.put(1,"c"); //key重复 会覆盖原有value
    System.out.println(map);//{1=c, 2=b}
     
    String val = map.get(1); //get通过key获取value
    System.out.println(val); //c
     
    map.remove(1); //移除
     
    //返回set keySet()返回所有key
    Set<Integer> keys = map.keySet();
     
    for(int i : keys){
        System.out.println(i+":" +map.get(i));
    }
     
    Entry 键值对对象
    Entry将将只对的对应关系封装成了对象,在遍历map集合时,就可以从每一个键值对Entry对象中获取对应的key与value。
    //返回set entrySet()返回所有entry对象
    Set<Map.Entry<Integer, String>> entrys = map.entrySet();
     
    for (Map.Entry<Integer, String> entry : entrys) {
        System.out.println(entry.getKey() + ":" + entry.getValue());
    }
     
    HashTable 线程安全集合,运行速度比较慢 不允许存null key,null value
    HashMap 线程不安全集合,运行速度快 可以存null key,null value
     
    静态导入
    import static XXX.YYY;   导入后YYY可直接使用
    import static java.util.Map.Entry;
            //for (Map.Entry<Student, String> entry : entrySet) {
            for (Entry<Student, String> entry : entrySet) {
     
    可变参数
    前提:方法参数的数据类型需要确定,参数的个数不确定。
    修饰符 返回值类型 方法名(参数类型… 参数名)
    public static void main(String[] args) {
        System.out.println(getSum(4,5,3,2,5,9));
    }
    public static int getSum(int... nums){
        int sum = 0;
        for(int i : nums){
            sum+=i;
        }
        return sum;
    }
    一个方法中可变参数只能有一个, 如果有多个参数,可变参数要再参数列表最后一个。
     
    Collections.sort 静态方法 对List集合升序排列
    List<String> list = new ArrayList<String>();
    list.add("sdf");
    list.add("abc");
    list.add("ccsl");
    System.out.println(list); //[sdf, abc, ccsl]
    Collections.sort(list);
    System.out.println(list); //[abc, ccsl, sdf]
     
    Exception 异常
    如数组越界等,程序会为使用者抛出异常,停止程序。
    throw关键字
    抛出一个异常。
     
    异常处理:
    try{
        可能出现异常的代码
    }catch(异常类名 变量){
        出现异常后执行的代码
    }finally{
        不管出现异常与否都执行的代码
    }
     
    int[] arrys = new int[]{1,2,3};
    try{
        int num = arrys[3];
        System.out.println(num);
    }catch (Exception ex){
        System.out.println(ex);
    }finally {
        System.out.println("都会执行");
    }
     
     
     
  • 相关阅读:
    构建一个真实的应用电子商务SportsStore3
    关于计算程序运行时间的方法汇总
    系统分析员备考之CMM篇
    大数据时代的技术hive:hive的数据类型和数据模型
    图片滚动图片的效果
    React初探
    所有的分页查询一览及数据导出(easyui + knouckoutjs + mvc4.0)
    golang微信公众平台之人脸识别
    测试rest接口的两个工具使用详解(restclient+soapUI)
    Linux系统服务基础
  • 原文地址:https://www.cnblogs.com/baidawei/p/8665283.html
Copyright © 2011-2022 走看看