java SE(上篇)完整详细笔记

最新推荐文章于 2024-07-27 17:56:15 发布
最新推荐文章于 2024-07-27 17:56:15 发布
阅读量615 收藏
点赞数
分类专栏： 笔记 文章标签： java javase api
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dlz0836/article/details/111303383
版权

文章目录

一、java SE(上篇)

示例：java是做后台服务器程序，c和c++是做本地应用程序。（安卓、服务器程序）

API接口

1.什么是JDK API

  • 工具 ，应用程序编程接口
    在这里插入图片描述
    2.JDK包结构
  • 包分类、解决类的命名冲突
  • java.lang 包很基础，不用import
  • java.io 、java.net、java.sql用的多
    在这里插入图片描述

文档注释

  • 文档注释可以通过javadoc工具 转换为HTML文档，普通无法通过工具生成文档。
    在这里插入图片描述
    4.文档注释规范
  • 功能说明、@author、@version、@see、 @since。
  • 文档注释可以写在类、方法、常量上
    在这里插入图片描述
    5.javadoc命令生成文档
  • 可以通过IDEA软件直接生成
    在这里插入图片描述
    在这里插入图片描述

字符串

1.字符串的本质是字符数组

  • C 没有String 类型 ，需要使用 字符数组来写 char[ ] name = new char[10]; name[0]= ‘1’;…
  • String str = “hello world!”;
  • 鼠标选中 Sting 然后 按 Ctrl + 右键
    在这里插入图片描述
public class Sting {
    public static void main(String[] args) {
        String str = "hello world!";
    }
}

2.String是不可变对象

  • 字符串一旦对应，对象是不变的
  • 基本数据类型： boolean、 byte、 char、 short、 int、 long、 float、 double 8种，特点：变量保存的是值本身。
  • 引用数据类型：数组、类 、枚举等 除了8种基础类型都是引用类型。包括Sting ，在内存是对象，既堆里的一块存储区域。特点：引用型变量定义的是对象在内存中的地址。
  • String str = “hello world!”; 在堆中创建 “hello world”的对象，对象一旦创建，对象的内容是永远 不会改变的。Sting 天生被final 修饰。 如果重新赋值的话只是会产生一个新的对象。引用指向了新的对象，老的对象等着被回收站回收。
    -
    2.String的特征
  • 计算机存取的字符串最大为 65536个
  • 字符串不能被继承
  • 字符串一旦创建，对象永远无法改变
  • 字符串内部 1个字符 是2个字节，因为char类型（2字节）

在这里插入图片描述
在这里插入图片描述

3.String的两种表示方法

public class Sting {
    public static void main(String[] args) {
        String str = "hello world!"; //字面量
        String str1 = new String("hello word"); //·String 是对象，正宗的表示方法
    }
}

4.String的常量池

  • 程序中因为存在大量重复的字符串，JAVA前辈所以做的优化，当字符串相同时实现了共用。
public class Sting {
    public static void main(String[] args) {
        String str = "hello world!"; 
        String str1 = "hello world!";
    }
}

在这里插入图片描述

在这里插入图片描述

  • 缺点：字符串一旦修改频繁，不利（GC频繁的回收）。
  • 在这里插入图片描述
public class Sting {
    public static void main(String[] args) {
        String str = "123hello world!";
        String str1 = "123hello world!";
         /*
          编译器小特性：
          当一个表达式运算两边都是字面量，那么编译的过程 就会进行计算，将结果生成在表达式的
          位置，可以节省运算时的开销
        * */
        String str3 = "123" + "hello world!";
        String str4 = 1+23+"hello world!";
        String str5 = 1+"23"+"hello world!";
        String str6 = "1"+23+"hello world!";
        String str7 = 1+'2'+"3"+"hello world!";
        
        /*
        * new 表示创建新对象，只有使用字面量赋值才会
        * 使用常量池中原来的对象进行重用
        *
        * */
        String str8 = new String("123Hello world!");

        //String str3 = "123hello world!";
        System.out.println(str  == str1); //true
        System.out.println(str3 == str1);//true
        System.out.println(str4 == str1);//false
        System.out.println(str5 == str1);//true
        System.out.println(str6 == str1);//true
        System.out.println(str7 == str1);//false
        System.out.println(str8 == str1);//false
    }
}

在这里插入图片描述

String的基本方法

在这里插入图片描述
1.indexOf方法
在这里插入图片描述

public class Sting1 {
    public static void main(String[] args) {
                 //   0123456789012345
        String str = "thinking in java";
        int index = str.indexOf("in");
        System.out.println("index：" + index);//2

        /*
         * indexOf(String str,int index)
         * 查找第一个参数要在当前字符串中找到
         * 然后返回第一个字母所在下标的位置
         */
        index = str.indexOf("in",3);
        System.out.println("index:" + index);//5

        /*
         *查找最后一次出现 参数的位置
         */
        index = str.lastIndexOf("in");
        System.out.println("index:"+index);//9

        //email
        String mail = "123123123.com";
               index = mail.indexOf("@");
        if (index <= 0 || index >= (mail.length()-1)){
            System.out.println("不是邮箱");
        } else{
            System.out.println("是邮箱");
        }

    }
}

2.substring方法
在这里插入图片描述

/**
 * String subString(int start,int end)
 * 截取当前字符串的部分内容
 *
 */
public class String2 {
    public static void main(String[] args) {
        //            012345678901234567890

        /*
         *使用数字表示范围，java都是含头不含尾
         */
        String str = "http://www.oracle.com";
        String subs = str.substring(11, 17); //oracle
        System.out.println(subs);//oracle.com
        /*
         *切一刀取后面
         */
        subs = str.substring(11);
        System.out.println(subs);

        /*
         *www.oracle.com
         * 获取域名
         * 思路：
         * 1：获取第一个"."的位置，对其+1后就是后面的第一个
         * 字符的位置
         * 2：获取第二个"."的位置
         */
        int start = str.indexOf(".");
        int end = str.indexOf(".",start + 1);
        subs = str.substring(start + 1, end);
        System.out.println(subs);
    }
}

3.charAt方法
在这里插入图片描述

/**
 * 或者指定位置的字符
 * char charAt(int index)
 */

public class String4 {
    public static void main(String[] args) {
        //            012345678
        String str = "helloword";
        char c = str.charAt(5);
        System.out.println(c);

        /*
         *检查回文
         * 上海自来水来自海上
         * 思路：
         * 1：循环判断
         * 2：正数位置上的字符与倒数位置的字符都一样
         */  //01  2 34 5 6 7 8
        str = "上海自来水来自海上";
        for(int i=0;i<str.length()/2;i++){
            if(str.charAt(i) != str.charAt(str.length() -1-i)){
                System.out.println("不是回文");
                return;
            }
        }
        System.out.println("是回文");
    }
}

4.startsWith 和 endsWith方法

/*
 *判断当前字符串是否是以给定的字符串开头或结尾的
 * boolean startsWith(String str)
 * boolean endsWith(String str)
 */
public class String5 {
    public static void main(String[] args) {
        String str = "ThinKing IN Java";
        boolean starts = str.startsWith("Thi"); 
        if(starts){
            System.out.println("开头"); //开头
        }else{
            System.out.println("不是开头");
        }
        boolean ends = str.endsWith(" Java");
        if(ends){
            System.out.println("结尾"); //结尾
        }else{
            System.out.println("不是结尾");
        }
        
        
    }
}

5.toUpperCase() 和 toLowerCase方法

import java.util.Random;
import java.util.Scanner;
/*
 *将当前字符串中英文部分转换为全大写或全小写
 * String toUpperCase()
 * String toLowerCase()
 */

public class String6 {
    public static void main(String[] args) {
     String str = "我爱Java";
     String upper = str.toUpperCase();
        System.out.println(upper); //我爱JAVA
     String lower = str.toLowerCase();
        System.out.println(lower); //我爱java

      //应用 ：验证码
      //1、产生验证码
        StringBuilder s = new StringBuilder();
        Random random = new Random();
        for(int i= 0;i<5;i++){
            int num = random.nextInt(3);
            switch (num){
                case 0:char r = (char) ((char)random.nextInt(26)+'a');
                    s.append(r);
                    break;
                case 1:char r1 = (char) ((char)random.nextInt(26)+'A');
                    s.append(r1);
                    break;
                case 2: s.append(random.nextInt(10));
                    break;
            }
        }

      //验证验证码
      System.out.println("请输入验证码：" + s);
      Scanner sc = new Scanner(System.in);
      String input = sc.next();
      s = new StringBuilder(s.toString().toLowerCase());
      input =input.toLowerCase();
      if(s.toString().equals(input)){
          System.out.println("验证成功");
        }else{
          System.out.println("验证失败");
        }

    }
}

5.trim() 方法

/*
 *去除字符串两边空白
 * String trim()
 */
public class String3 {
    public static void main(String[] args) {
        String str = "   hello world            ";
        String trim =str.trim();
        System.out.println(str); //   hello world
        System.out.println(trim);//hello world
    }
}
//应用：取出url的空白 或者密码的空白

5.valueOf方法

/**
 * valueOf() 有多种重载形式
 * 常用将8种基本类型转换为字符串类型
 */
public class String7 {
    public static void main(String[] args) {
        int i = 100;
        double d = 152.365;

        String is = String.valueOf(i);
        String ds = is + d;
        System.out.println(ds); //100152.365

        String str = 100 + "";
        System.out.println(str); //100
    }
}

StringBuilder及其API

  • 由于字符串是固定不变的，不适合频繁修改，因此JAVA中有一个类StringBuilder是专门用来修改字符串的，其本身不是字符串，优点是节省内存空间。比如修改了字符串"a" +=“a”,对于字符串而言，需要再创建一个新的对象。单对于StringBuilder而言，不需要再创建一个新的字符串，而是在老的对象后面追加一个a。✌

1.常用方法-增删改插
在这里插入图片描述

/**
 * StringBuilder 用于解决字符串频繁修改带来的内存消耗
 * 所以将来我们频繁修改字符串的内容这样的操作时，首先使用
 * StringBuilder
 */
public class StringBuilderDome {
    public static void main(String[] args) {
        //内部默认为空字符串
        StringBuilder builder = new StringBuilder();
          //内部默认为字符串：hello world
        //StringBuilder builder1 = new StringBuilder("hello world");

        //append 追加
        //               01 2 3 4 56 7 8 9 01 2 3 4 5
        builder.append("努力学大数据开发，为了找个好工作");
        String str = builder.toString();
        System.out.println(str);

        //replace 替换
        builder.replace(9,16,"为了改变世界");
        str = builder.toString();
        System.out.println(str);

        //delete 删除
        builder.delete(0,8);
        str = builder.toString();
        System.out.println(str);


        //活着,为了改变世界
        builder.insert(0,"活着"); //从 0开始往后移
     /*   str = builder.toString();
        System.out.println(str);*/
        //简写优化，从下之上，等量代换
        System.out.println(builder.toString());
    }
}

运行结果：

努力学大数据开发，为了找个好工作
努力学大数据开发，为了改变世界
，为了改变世界
活着，为了改变世界

Process finished with exit code 0

2.return this在这里插入图片描述
3.** reverse **

/**
 * reverse 字符串反转
 */
public class StringBuilderDemo1 {
    public static void main(String[] args) {
        String str = "上海自来水来自海上";
        StringBuilder builder = new StringBuilder(str);
        builder = builder.reverse();
        String str2 = builder.toString();
        System.out.println(str2); //上海自来水来自海上
        if(str.equals(str2)){ //是回文
            System.out.println("是回文");
        }else {
            System.out.println("不是回文");
        }
    }
}

4.Stringbuffer 和 StringBuilder
在这里插入图片描述
5.汉字的unicode编码
汉字的起始：char c = ‘\u4e00’;
汉子的结束：char c = ‘\u9fa5’

public class hanzi {
    public static void main(String[] args) {
        char c = '\u4e00';
        for(int i=0;i<10;i++){
            c+=i;
            System.out.print(c + "  ");
        }
    }
}

一  丁  七  丆  上  丏  丕  东  两  中

正则表达式

1.正则表达式
什么是正则表达式：用一组特殊的字符描述的一个字符串格式，作用是匹配一个字符串是否满足格式要求。只关注格式是否正确，不关心内容是否有效
在这里插入图片描述
2.常见的正则表达式
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
（+\86）?13512345678
^ [0-9]{11}$ :^ 开始 $ 结束

3.使用matches( ) 方法匹配
* boolean matches(String regex)
* 使用给定的正则表达式验证当前字符串是否满足
* 格式要求，满足返回true
* 字符串matches 方法是全匹配的

4.举例验证邮箱和身份证号

/**
 * 字符串支持正则表达式的方法1:
 * 匹配格式
 */
public class StringDemo1 {
    public static void main(String[] args) {
        /*
         * 邮箱地址
         * [a-zA-Z0-9_]+@[a-zA-Z0-9_]+(\.[a-zA-Z0-9])+
         */
        String regex = "[a-zA-Z0-9_]+@[a-zA-Z0-9_]+(.[a-zA-Z0-9])+";
        System.out.println(regex);

        String email = "lzdeng103@fiberhome.com";
        /*
         * boolean matches(String regex)
         * 使用给定的正则表达式验证当前字符串是否满足
         * 格式要求，满足返回true
         */
        boolean match = email.matches(regex);
        System.out.println(match);
        if(match){
            System.out.println("是邮箱");
        }else{
            System.out.println("不是邮箱");
        }
    }
}

/**
 * 身份证号验证
 */
public class StringDemo2 {
    public static void main(String[] args) {
        /*
         * \d{15}(\d{2}[0-9xX])?
         */
        String regex = "\\d{15}(\\d{2}[0-9xX])?";
        String id = "42232619950512641x";
        boolean math = id.matches(regex);
        if(math){
            System.out.println("身份证号正确！");
        }else{
            System.out.println("身份证号有误！");
        }

    }
}

5.Split方法的作用
在这里插入图片描述
练习：

/**
 * String split(String regex)
 * 当钱字符串满足正则表达式的部分拆分
 *
 */
public class StringDemo3 {
    public static void main(String[] args) {
        String str = ",,,boss,jack,,marry,jackson,,,";
        String [] arr = str.split(",");
        System.out.println(arr.length);
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

运行结果：

8



boss
jack

marry
jackson

6.replaceAll方法
在这里插入图片描述
练习：



```java
/**
 * 将字符串中满足正则表达式的部分替换成给定的内容
 * String replaceAll(String regex,String replace)
 */
public class StringDemo4 {
    public static void main(String[] args) {
     String str = "ab123lask123123dflk9824kj94kj0909";
     str = str.replaceAll("\\d+","#num#");
        System.out.println(str);
    }
}

运行结果：

ab#num#lask#num#dflk#num#kj#num#kj#num#


/**
 * 作用：游戏里的 用来和谐的 你个**
 */

object

1.所有类都继承自object，因为所有的类都是对象
在这里插入图片描述
2.toString方法
在这里插入图片描述
在这里插入图片描述

public class Teacher {
    private String name;
    private int age;
    private String gender;

    public static void main(String[] args) {
        Teacher p = new Teacher();
        p.name = "哇哈哈";
        p.age = 10;
        p.gender = "男";
       /* String str = p.toString();
        System.out.println(str);*/
        /*
         *System.out.println(Object obj)
         * 将给定对象的toString()方法返回的字符串
         * 输出到控制台
         */
        System.out.println(p);

    }
    public String toString(){
        return name+","+age+","+gender;
    }
}


哇哈哈,10,男

3.equals方法

  • == 比较的是是否为同一个对象
  • equals 比较两个对象像不像

在这里插入图片描述
在这里插入图片描述

public class Teacher {
    private String name;
    private int age;
    private String gender;

    public static void main(String[] args) {
        Teacher p = new Teacher();
        p.name = "哇哈哈";
        p.age = 10;
        p.gender = "男";
       /* String str = p.toString();
        System.out.println(str);*/
        /*
         *System.out.println(Object obj)
         * 将给定对象的toString()方法返回的字符串
         * 输出到控制台
         */
        System.out.println(p);

        Teacher p2 = new Teacher();
        p2.name = "哇哈哈";
        p2.age = 10;
        p2.gender = "男";

        System.out.println(p==p2); //false
        System.out.println(p.equals(p2)); //true ,如果没有重写则返回的是false
    }
    public String toString(){
        return name+","+age+","+gender;
    }
    /*
     *改方法用来判断当前对象与给定的对象"长得像不像"
     * 比较内容(属性)
     */
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (obj == this) {
            return true;
        }
        if(obj instanceof Teacher){
            Teacher t = (Teacher)obj;
            return t.name.equals(this.name)
                    &&
                    t.age == this.age
                    &&
                    t.gender.equals(this.gender);
        }
        return false;
    }
}

基本类型包装类

1.包装类概述
在这里插入图片描述
int —Integer char -Character
包装类都是final的不能再定义子类
在这里插入图片描述

/**
 * 包装类
 * 用于使基本类型可以参与面向对象开发
 */
public class IntegerDemo {
    public static void main(String[] args) {
        Integer i = new Integer(1);
        Double d = new Double(1.2);
        Short s = new Short((short) 1);
        Byte b = 1;
    }

    public static void dosome(Object obj){}
}

2.Number类及其主要方法
在这里插入图片描述

public class IntegerDome2 {
    public static void main(String[] args) {
        Double d = 123.456;
        double dd = d.doubleValue();
        System.out.println(dd);

        int i = d.intValue();
        System.out.println(i);

        short s = d.shortValue();
        System.out.println(s);
        byte b = d.byteValue();
        System.out.println(b);
    }
}

123.456
123
123
123

3.编译器对包装类的支持
在这里插入图片描述
4.Integer和Double常用方法之 MAX_VALUE, MIN_VALUE, parselnt(“123”)，parseDouble(“123.456”)，toBinaryString(100)在这里插入代码片 ，toHexString(100)
在这里插入图片描述

Date和DateFormat

1.Date类及其常用方法
在这里插入图片描述
在这里插入图片描述

import java.util.Date;

/**
 * java.util.Date
 * 该类的每一个实例用于表示一个时间
 */
public class DateDome {
    public static void main(String[] args){
        /*
         *默认表示当前系统时间
         */
        Date date = new Date();
        System.out.println(date);
        /*
         *获取该Date内部维护的long值
         * 表示从1970-1-1 00:00:00着一刻
         * 的毫秒值
         */
        long time = date.getTime();
        System.out.println(time);
        /*
         *让当前date表示给定毫秒所表示的时间
         */
        date.setTime(time +24*60*60*1000);
        System.out.println(date);
    }
}

运行结果：

Wed Dec 23 11:23:24 CST 2020
1608693804488
Thu Dec 24 11:23:24 CST 2020

2.SimpleDateFormat——format方法

  • 根据特定的日期格式,使得字符串和Date之间相互转换
    在这里插入图片描述
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * SimpleDateFormat可以根据给定的日期格式字符串
 * 使得可以在Date和String之间相互转换
 *
 */
public class SimpelDateFormatDome {
    public static void main(String[] args) {
        //表示当前系统时间
        Date date = new Date();
        //输出Date默认的toString方法输出
        System.out.println(date);

        /*
         希望输出格式是：2020/12/23 11:03
         */
        String dateFormat =
                "yyyy/MM/dd HH:mm:ss E a";
        /*
         *java.text.SimpleDateFormat
         * 创建需要制订日期格式，该类会根据
         * 给定的格式进行转换工作
         */
        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
        /*
         *String.format(Date date)
         * 将给定的Date按照SimpleDateFormat指定
         * 的日期转换位字符串
         */
        String str = sdf.format(date);
        System.out.println(str);
    }
}

运行结果：

Wed Dec 23 11:21:39 CST 2020
2020/12/23 11:21:39 周三 上午

Process finished with exit code 0

3.SimpleDateFormat——parse方法
在这里插入图片描述
4.常用字符串格式
在这里插入图片描述
4.DateFormat类
在这里插入图片描述

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 使用SimpleDateFormat的parse方法
 * 将字符串转换为Date
 */
public class StringDateFormatDome2 {
    public static void main(String[] args) throws ParseException {
        String str = "2021-1-1 00:00:00";
        String format = "yyyy-MM-dd HH:mm:ss";
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        /*
         *Date parse(String str)
         * 将给定的字符串按simpleDateFormat指定
         * 的日期格式并转换为Date对象返回
         */
        Date date = sdf.parse(str);
        System.out.println(date);
    }
}


Fri Jan 01 00:00:00 CST 2021

练习：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

/**需求：
 * 输入一个生日
 * 计算度过了多少个日夜
 */
public class SimpleDateFormatDome3 {
    public static void main(String[] args) throws ParseException {
        /*
         *思路：
         * 1.将生日字符串转换为Date
         * 2.创建一个Date表示系统时间(今天)
         * 3.截取今天毫秒值
         * 4.截取生日的毫秒值
         * 5.用今天的毫秒值-生日的毫秒值
         * 6.计算度过了多少毫秒 除以一天的毫秒值
         * 7.输出度过了多少天
         */
        System.out.println("请输入一个生日，格式(yyyy年MM月dd日):");
        Scanner sc = new Scanner(System.in);
        String sr = sc.next();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
        Date d1 = sdf.parse(sr);
        long d11 = d1.getTime();
        //获取当前系统时间
        Date d2 = new Date();
        long d22 =d2.getTime();
        long d33 = d22 - d11;
        System.out.println(d33/(24*60*60*1000));
    }
}

请输入一个生日，格式(yyyy年MM月dd日):
2000年1月1日
7662

calendar类

1.静态方法getInstance( )
在这里插入图片描述
2.getTime( )方法

import java.util.Calendar;
import java.util.Date;

/*
 * 日历类
 * 用于操作时间的类
 */
public class CalendarDome {
    public static void main(String[] args) {
        /*
         * 默认创建的Calendar表示当前系统时间
         */
        Calendar cal = Calendar.getInstance();
        System.out.println(cal);
        /*
         * Date getTime()
         * 该方法用于获取一个Date对象，该对象表示的时间
         * 就是当前Calendar所表示的时间
         */
        Date date = cal.getTime();
        System.out.println(date);


    }
}

java.util.GregorianCalendar[time=1608705019958,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=31,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2020,MONTH=11,WEEK_OF_YEAR=52,WEEK_OF_MONTH=4,DAY_OF_MONTH=23,DAY_OF_YEAR=358,DAY_OF_WEEK=4,DAY_OF_WEEK_IN_MONTH=4,AM_PM=1,HOUR=2,HOUR_OF_DAY=14,MINUTE=30,SECOND=19,MILLISECOND=958,ZONE_OFFSET=28800000,DST_OFFSET=0]
Wed Dec 23 14:30:19 CST 2020

Process finished with exit code 0

3.setTime( )方法

import java.util.Calendar;
import java.util.Date;

/*
 * Date 与 Calendar 的转换
 */
public class CalendarDome2 {
    public static void main(String[] args) {
        //已有一个Date对象
        Date date = new Date();

        /*
         * 希望使用Calendar表示当前Date所表示的时间
         */
        Calendar cal = Calendar.getInstance();
        /*
         *  Calendar 提供一个方法
         * void setTime(Date date)
         * 该方法用于是使得当前Calendar表示给定的
         * Date所表示的时间
         */
        cal.setTime(date);
    }
}

4.Calendar分量运行
在这里插入图片描述
在这里插入图片描述
设置时间

import java.util.Calendar;
import java.util.Date;

/**
 * 使用Calendar设置时间
 *
 */
public class CalendarDome3 {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        /*
         * 希望表示2021-1-1 00:00:00
         */
        cal.set(Calendar.YEAR,2021);
        /*
         *月份值可以使用常量
         * 也可以直接给定值，需要注意：月份从0开始
         * 既0表示1月
         */
        cal.set(Calendar.MONTH,0);//月从0开始
        /*
         * Calendar.Date 与 Calendar.DAY_OF_MONTH
         * 等价
         */
        cal.set(Calendar.DAY_OF_MONTH,1);
        cal.set(Calendar.HOUR_OF_DAY,0);
        cal.set(Calendar.MINUTE,0);
        cal.set(Calendar.SECOND,0);

        Date date = cal.getTime();
        System.out.println(date);
    }
}



Fri Jan 01 00:00:00 CST 2021

Process finished with exit code 0

获取时间

import com.lagu.homwork2.CallServerInterface;

import java.util.Calendar;

/**
 * 获取Calendar中某个时间分量对应的值
 */
public class CalendarDome4 {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        /*
         * int get(int field)
         * 根据给定的时间分量获取对应的值
         */
        int year = cal.get(Calendar.YEAR);
        int moon = cal.get(Calendar.MONTH)+1 ;

        cal.set(Calendar.DAY_OF_MONTH,27);
        int day  = cal.get(Calendar.DAY_OF_MONTH);
        int week = cal.get(Calendar.DAY_OF_WEEK)-1; //星期天是第一天
        System.out.println(year +"-"+moon+"-"+day);
        System.out.println("星期："+ (week==0?7:week));
    }
}


2020-12-27
星期：7

Process finished with exit code 0

使用Calendar计算时间

import java.util.Calendar;
import java.util.Date;

/**
 * 使用Calendar计算时间
 */
public class CalendarDome5 {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        /*
         *void add(int field,int n)
         * 为当前Calendar指定时间分量上累加给定值
         * 若传入负数，则是累减
         */
        cal.add(Calendar.DAY_OF_YEAR,15);
        Date date = cal.getTime();
        System.out.println(date);
    }
}

Thu Jan 07 16:54:47 CST 2021

Process finished with exit code 0

计算三个月后的10天后的那周的周三

import java.util.Calendar;

/**
 * 计算三个月后的10天后的那周的周三
 */
public class CalendarDome6 {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.MONTH,3);
        cal.add(Calendar.DAY_OF_YEAR,10);
        cal.set(Calendar.DAY_OF_WEEK,4);
        System.out.println(cal.getTime());

    }
}

计算时间分量的最大值

import java.util.Calendar;

/**
 * 计算时间分量的最大值
 */
public class CalendarDome7 {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();

        /*
         *获取当月有多少天
         */
        int days = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
        System.out.println(days);//31
    }
}

输入一个日期，输出3年，3个月，3天后的当周的周三的日期

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;

/**
 * 输入一个日期，输出3年，3个月，3天后的当周的周三的日期
 */
public class CalendarDome8 {
    public static void main(String[] args) throws ParseException {
        /*
         *1、输入日期:字符串转换为Date->Calendar
         *2、加上三年三月三天
         *3、确定当周是那周
         *4、输出日期+4
         */
        //输入日期字符串
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个日期:(格式：yyyy-MM-dd)");
        String dateStr = scanner.next();
        //字符串转换为日期
        String format = "yyyy-MM-dd";
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Date dateInput = sdf.parse(dateStr);
        System.out.println(dateInput);
        //将Date转换为Calendar
        Calendar cal = Calendar.getInstance();
        cal.setTime(dateInput);

        //计算时间
        cal.add(Calendar.YEAR,3);
        cal.add(Calendar.MONTH,3);
        cal.add(Calendar.DAY_OF_MONTH,3);
        cal.set(Calendar.DAY_OF_WEEK,4);

        //将Calendar转换为Date
       Date date = cal.getTime();
        System.out.println(date);

        //将Date转换为字符串
       String str = sdf.format(date);
       System.out.println(str);
       
    }
}


请输入一个日期:(格式：yyyy-MM-dd)
2020-12-24
Thu Dec 24 00:00:00 CST 2020
Wed Mar 27 00:00:00 CST 2024
2024-03-27


import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;

/**
 * 输入生产日期和保质期，输出
 */
public class ShelfLifeDome {
    public static void main(String[] args) throws ParseException {
        //1.创建Scanner
        Scanner sc = new Scanner(System.in);
        //2.接收生产日期
        System.out.println("请输入生产日期：（格式yyyy-MM-dd）");
        String produceDate = sc.next();
        //3.接收保质期
        System.out.println("请输入保质期：(天)");
        int bzq = sc.nextInt();
        //4.将字符串转换为Date
        String format = "yyyy-MM-dd";
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Date date  = sdf.parse(produceDate);
        //5.将Date转换为Calendar
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        //加上保质期天数
        cal.add(Calendar.DAY_OF_YEAR,bzq);
        //减去14天
        cal.add(Calendar.DAY_OF_YEAR,-14);
        //设置为当周的周三
        cal.set(Calendar.DAY_OF_WEEK,4);
        //Calendar转换为Date
        date = cal.getTime();
        //将Date 转化为字符串
        String str = sdf.format(date);
        //输出
        System.out.println(str);

    }

}

集合框架

1.List和Set

在这里插入图片描述
2.集合的基本操作
集合保存元素的地址
在这里插入图片描述
举例：
1.先添加coll类

/**
 * 作为集合元素进行测试的类
 *
 */
public class Coll {
   int x;
   int y;
    public Coll(int x,int y){
        this.x = x;
        this.y = y;
    }

    @Override
    public String toString() {
        return
               "[" + "x=" + x +
                ", y=" + y + "]";
    }
}


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

/**
 *
 */
public class CollectionDome {
    public static void main(String[] args) {
        Collection c = new ArrayList();

        Coll coll1 = new Coll(1,2);
        Coll coll2 = new Coll(3,4);

        c.add(coll1);
        c.add(coll2);
        System.out.println(c);
        coll1.x = 2;
        System.out.println(c);
    }
}

在这里插入图片描述

查看集合是否包含给定元素

import java.util.Objects;

/**
 * 作为集合元素进行测试的类
 *
 */
public class Coll {
     int x;
     int y;
    public Coll(int x,int y){
        this.x = x;
        this.y = y;
    }

    @Override
    public String toString() {
        return
               "[" + "x=" + x +
                ", y=" + y + "]";
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Coll coll = (Coll) o;
        return x == coll.x &&
                y == coll.y;
    }

}


/**
 * 查看集合是否包含给定元素
 */
public class CollectionDome2 {
    public static void main(String[] args) {
        Collection c = new ArrayList();

        Coll coll1 = new Coll(1,2);
        Coll coll2 = new Coll(2,3);
        Coll coll3 = new Coll(3,4);
        c.add(coll1);
        c.add(coll2);
        c.add(coll3);

        Coll coll4 = new Coll(3,4);
        System.out.println(coll3.equals(coll4)); //false 是因为 没有重写equals ，默认是 判断是否为同一个对象。但是不是同一个对象
        /**
         * boolean contains(Object o)
         * 查看当前集合是否包含给定的元素o
         *
         *包含取决于集合的元素是否与有给定元素
         * equals比较为true的。
         */
        if(c.contains(coll4)){
            System.out.println("包含");
        }else {
            System.out.println("不包含");
        }

    }
}


true
包含

Process finished with exit code 0

集合的其它方法

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

/**
 * 集合的其它方法
 */
public class CollectionDome3 {
    public static void main(String[] args) {
        Collection c = new ArrayList();

        /*
         *int size()
         *获取集合元素个数
         */
        int s = c.size();
        System.out.println(s);
        /*
         *boolean isEmpty()
         *查看集合是否不包含任何元素
         */
        boolean e  = c.isEmpty();
        System.out.println("不含元素：" + e);

        c.add("1");
        c.add(new Date());

        System.out.println(c.size());
        System.out.println("不含元素：" + c.isEmpty());
        /*
         *清空元素
         */
        c.clear();
        System.out.println(c.size());
        System.out.println("不含元素：" + c.isEmpty());
    }
}


0
不含元素：true
2
不含元素：false
0
不含元素：true

2.addAll、ContainsAll
在这里插入图片描述
集合的批量处理方法

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

/**
 * 集合的批量处理方法
 */
public class CollectionDome1 {
    public static void main(String[] args) {
        Collection c1 = new ArrayList();
        c1.add("java");
        c1.add(".net");
        c1.add("c#");
        c1.add("php");
        System.out.println(c1);
        Collection c2 = new ArrayList();
        c2.add("android");
        c2.add("ios");
        /*
         * boolean addAll(Collection c)
         * 将给定的集合中的所有元素添加到当前集合中
         * 当调用该方法后当前元素数列发生了变化
         * 则返回true
         */
        c1.addAll(c2);
        System.out.println(c1);

    }
}


[java, .net, c#, php]
[java, .net, c#, php, android, ios]

3.删除元素

import com.lagu.homwork2.com.danei.SE01.day03.Coll;

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

/**
 * 删除元素
 */
public class CollectionDome2 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add(new Coll(1,2));
        c.add(new Coll(2,3));
        c.add(new Coll(1,2));

        Coll cell = new Coll(1,2);
        System.out.println(c);
        /*
         * boolean remove(Object o)
         * 从当前集合中删除给定元素的第一个equals比较
         * 为true的
         * 删除元素是根据元素的equals的结果判断的
         */
        c.remove(cell);
        System.out.println(c);
    }
}

[[x=1, y=2], [x=2, y=3], [x=1, y=2]]
[[x=2, y=3], [x=1, y=2]]

Process finished with exit code 0

4.迭代器–用来遍历集合

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

/**
 * 迭代器用来遍历集合
 */
public class IteratorDome {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");
        c.add("e");

        /*
         *Iterator是一个接口
         * java希望我们使用统一的方式遍历所有集合
         * 使用迭代器遍历集合必须遵循以下过程：
         * 问，取，删（删除不是必须的操作）
         */
        Iterator it = c.iterator();
        /*
         *boolean hasNext();
         *询问迭代器，遍历的集合是否还有元素可以取出
         */
        while (it.hasNext()){
            Object o = it.next();
            String str = (String)o;
            System.out.println(str);
        }
    }
}


a
b
c
d
e

Process finished with exit code 0

遍历删除某些元素

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

/**
 * 遍历删除某些元素
 * 想要it.remove()  先要 it.next() 取出元素，想要取出元素 先要  it.hasNext()判断有么有
 */
public class IteratorDome2 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("one");
        c.add("#");
        c.add("two");
        c.add("#");
        c.add("three");
        c.add("#");
        c.add(null);
        c.add("four");
        System.out.println(c);

        Iterator  it = c.iterator();
        while (it.hasNext()){
            /*
             *it.next 取出元素
             */
            String str = (String)it.next();
        //    if(str.equals("#")){ //error “null不能.” 集合可以存在空 ，会造成异常
            /*
             * 尽量使用字面量.equals(变量)
             * 这样可以避免空指针异常的产生
             */
              if("#".equals(str)){
                  /*
                   * 在使用迭代器遍历集合的过程中
                   * 不可以通过集合的相关方法改变
                   * 集合元素
                   */
               // c.remove(str); error
                  /*
                   *迭代器的remove方法用来从集合中
                   * 删除刚刚next()出来的元素
                   */
                  it.remove(); 
              }
        }
        System.out.println(c);
    }
}

5.增强型for循环
在这里插入图片描述
新循环只能用来遍历集合

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

/**
 * 新循环，又名：增强for循环，for each
 * 从java 1.5（5.0）后退出的新特性
 * 新循环不能代替传统循环的工作，
 * 新循环只能用来遍历集合或数组
 */
public class NewForDome {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("one");
        c.add("two");
        c.add("#");
        c.add("three");
        c.add("four");

        /*
         * for(Object o : c){}
         * 等价于：
         * Iterator it = c.iterator();
         * while(it.hasNext){
         * Object o = it.next();
         * }
         */

        /*
         *新循环并非新的语法，之上编译器在编译成
         * class文件时，新循环转换为了迭代器
         * 所以，在新循环遍历集合时，不能通过
         * 集合的方法来改集合元素
         */
        for(Object o : c){
            String str = (String) o;
            System.out.println(str);

        }
        // 左边是类型 变量，集合默认都是Object 类型 ，右边是要接收的集合或数组名
    }
}


one
two
#
three
four

Process finished with exit code 0

在这里插入代码片

新循环遍历数组

/**
 * 新循环遍历数组
 */
public class NewForDome2 {
    public static void main(String[] args) {
        String[] array = {"1","2","3","4","5"};
        for(int i=0;i<array.length;i++){
            System.out.print(array[i] + " ");
        }
        for(String str:array){
            System.out.print(str + " ");
        }
    }
}



/**
 * 新循环遍历数组
 */
public class NewForDome2 {
    public static void main(String[] args) {
        String[] array = {"1","2","3","4","5"};
        for(int i=0;i<array.length;i++){
            System.out.print(array[i] + " ");
        }
        System.out.println();
        for(String str:array){
            System.out.print(str + " ");
        }
    }
}

1 2 3 4 5 
1 2 3 4 5 
Process finished with exit code 0

泛型机制

1.泛型机制简介在这里插入图片描述

public class TypeDome<T> {
    private T x;
    public TypeDome(T x){
        this.x = x;
    }

    public T getX() {
        return x;
    }

    public void setX(T x) {
        this.x = x;
    }

    @Override
    public String toString() {
        return
                "x=" + x ;
    }
}


public class TestTypeDome {
    public static void main(String[] args) {
        TypeDome<String> t = new TypeDome<String>("1");
        System.out.println(t.toString());

        TypeDome<Integer> i = new TypeDome<>(1);
        System.out.println(t.toString());

    }
}


x=1
x=1

Process finished with exit code 0

2.java泛型在集合中的运用
在这里插入图片描述

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

/**
 * 所有的集合都支持泛型
 * 而集合中 泛型用来定义定义的元素类型
 */
public class CollectionDome3 {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<String>();
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");

        for(Object o: c){
            System.out.println(o);
        }
        Iterator<String> it = c.iterator();
        while (it.hasNext()){
            String str  = it.next();
            System.out.println(str);
        }
    }
}


one
two
three
four
one
two
three
four

Process finished with exit code 0

List

1.ArrayList 和 LinkedList

ArrayList 更适合查找，而LinkedList更适合插入和删除
在这里插入图片描述
在这里插入图片描述
2. get 和 set方法
这些都是List独有的方法
在这里插入图片描述
List 集合获取和替换元素

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

/**
 * List 集合，通常是有序集
 * 特点是库根据下标操作元素
 */
public class ListDome {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("one");
        list.add("two");
        list.add("three");
        list.add("four");

        /*
         * T get(int index)
         * 获取给定下标所对应的元素
         */
        String str = list.get(2);
        System.out.println(str);
        /*
         * List集合可以通过以下标遍历集合每个元素
         */
        for(int i=0;i<list.size();i++){
            str = list.get(i);
            System.out.println(str);
        }

        /*
         * T set(int index,T t)
         * 将给定的元素设置的位置上
         * 返回值为原位置上的元素
         * 所以该方法是替换元素操作
         */
        System.out.println(list);
        String old = list.set(1,"2");
        System.out.println(list);
        System.out.println("被替换的元素：" + old);

    }
}


three
one
two
three
four
[one, two, three, four]
[one, 2, three, four]
被替换的元素：two

Process finished with exit code 0

List集合的方法插入与删除

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

/**
 * List集合的方法
 * 插入与删除
 */
public class ListDome2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("one");
        list.add("two");
        list.add("three");

        /*
         * void add(int index,T t)
         * 将给定的元素添加到给定的位置上
         * 原位置及后续元素顺序向后移动
         * 插入操作。
         */
        System.out.println(list);
        list.add(1,"2");
        System.out.println(list);

        /*
         * E remove(int index)
         * 删除给定位置上的元素
         * 返回值为被删除的元素
         */
        String remove = list.remove(2);
        System.out.println(list);
        System.out.println("被删除的是:" + remove);

    }

}


[one, two, three]
[one, 2, two, three]
[one, 2, three]
two

Process finished with exit code 0

3.subList方法在这里插入图片描述
在这里插入图片描述

List的方法获取子集

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

/**
 * List的方法
 * 获取子集
 */
public class ListDome3 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
        System.out.println(list);

        /*
         * List subList(int Start,int end)
         * 获取当前结合中的子集
         */
        List<Integer> subList = list.subList(3, 8);
        System.out.println(subList);

        /*
         * 将子集的元素扩大10倍
         */
        for(int i=0;i<subList.size();i++){
            int num = subList.get(i);
            num *=10;
            subList.set(i,num);
        }
        System.out.println(subList);
        /*
         * 修改子集元素，会影响原集合
         */
        System.out.println(list);

    }
}


[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[3, 4, 5, 6, 7]
[30, 40, 50, 60, 70]
[0, 1, 2, 30, 40, 50, 60, 70, 8, 9]

Process finished with exit code 0

4.List转换为数组
在这里插入图片描述
集合转为数组

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

/**
 * 集合转换为数组
 * Collection 中定义了两个方法
 * Object[] toArray[]
 * <T>T[] toArray(T[] array)
 */
public class ToArrayDome {
    public static void main(String[] args) {
        Collection<String> c  = new ArrayList<String>();

        c.add("one");
        c.add("two");
        c.add("three");

//        Object[] array = c.toArray();
        /*
         * 传入的数组长度有区别
         * 若给定的数组长度不足以保存集合中所有元素
         * 集合子集创建一个同类型数组
         * 若长度够长，则使用我们给定的数组
         */
        String[] array = c.toArray(new String[10]);
        System.out.println(array); //返回的是地址
        
        for(String str:array){
            System.out.println(str);
        }
    }
}

one
two
three
null
null
null
null
null
null
null

Process finished with exit code 0

数组转换为List集合

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

/**
 * 数组转换为List集合
 * 不能转换为Set集合，原因在于set集合不能存放重复元素
 */
public class ToListDome {
    public static void main(String[] args) {
        String[] array = {"1","2","3","4","5"};
        /*
         *通过Arrays转换的集合是不能添加新元素的
         */
        List<String> list = Arrays.asList(array);
        System.out.println(list);
        /*
         *所有的集合（包括Set集合）都支持一个构造方法，
         * 参数传入一个Collection这个构造方法的好处是，
         * 在创建当前集合时默认就包含给定集合中的所有
         * 元素
         */
        List<String> list1 = new ArrayList<String>(list);
        list1.add("6");
        System.out.println(list1);
    }
}

6.Conllections.sort方法
在这里插入图片描述

import java.util.*;

/**
 * 集合排序
 */
public class SortCollection {
    public static void main(String[] args) {
        List<Integer> c = new ArrayList<>();
        Random random = new Random();
        for (int i=0;i<10;i++){
            c.add(random.nextInt(100));
        }
        System.out.println(c);
        /*
         *通过Collections 这个集合的工具类
         *我们可以对List集合进行自然排序
         */
        Collections.sort(c);
        System.out.println(c);
    }
}


[64, 23, 74, 68, 76, 16, 8, 48, 95, 12]
[8, 12, 16, 23, 48, 64, 68, 74, 76, 95]

Process finished with exit code 0


import com.lagou.task10.StaticOuter;
import com.lagu.homwork2.com.danei.SE01.day03.Coll;
import com.lagu.homwork2.com.danei.review.taks1.Cell;

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

/**
 * Comparable接口
 */
public class SortCollection2 {
    public static void main(String[] args) {
        List<Coll> list = new ArrayList<Coll>();
        list.add(new Coll(4,5));
        list.add(new Coll(1,7));
        list.add(new Coll(1,2));
        list.add(new Coll(3,3));
        System.out.println(list);
        /*
         * 使用Collections的sort方法进行排序的集合，
         * 要求元素必须实现Comparable接口
         * 只有实现了该接口才认为是可比较的元素
         */
        Collections.sort(list);
        System.out.println(list);
    }
}

6.Comparable接口
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package com.lagu.homwork2.com.danei.SE01.day03;

import java.util.Objects;

/**
 * 作为集合元素进行测试的类
 *
 */
public class Coll implements Comparable<Coll>{
     int x;
     int y;
    public Coll(int x,int y){
        this.x = x;
        this.y = y;
    }

    @Override
    public String toString() {
        return
               "[" + "x=" + x +
                ", y=" + y + "]";
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Coll coll = (Coll) o;
        return x == coll.x &&
                y == coll.y;
    }

    /*
     * 返回值不关注具体的值，值关注取值范围
     * 返回值<0:当前对象比给定的对象小
     * 返回值=0：当前对象相当
     * 返回值>0: 当前对象比给定的对象大
     */
    @Override
    public int compareTo(Coll o) {
        /*
         * 比较规则如下
         * y值大就大
         */
        return this.y - o.y;
    }
}

重新定义比较器

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class sortCollection3 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("boss");
        list.add("王麻子");
        list.add("德玛西亚");
        list.add("嘉文");
        System.out.println(list);
        Comparator<String> com = new MyComparator();
        Collections.sort(list,com);
        System.out.println(list);


    }
}


/**
 *何时应该声明比较器
 * 当集合中的元素已经实现了Comparable接口，并且实现了
 * 比较规则，但是该比较规则不能满足我们对于排序的需求时
 * 我们可以额外定义一个比较规则
 */
class  MyComparator implements Comparator<String> {
    /*
     *自定义比较字符串的规则，字符串多的大
     */
    public int compare(String o1,String o2) {
        return o1.length() - o2.length();
    }
}

[张三, boss, 王麻子, 德玛西亚, 嘉文]
[张三, 嘉文, 王麻子, boss, 德玛西亚]

Process finished with exit code 0

/**
 * 创建集合实现  工资从小打大排序
 */

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class A001 {
    public static void main(String[] args) {
        List<Emp> e = new ArrayList<Emp>();
        e.add(new Emp("Terry",27,9000));
        e.add(new Emp("Allen",25,8000));
        e.add(new Emp("Smith",24,6500));
        System.out.println(e);
        /*
         * 何时使用匿名内部类：
         * 当我们需要用到一个实例，而该实例所属的类
         * 需要实现一个接口或者继承一个类，并且该实例
         * 仅在这里用一次，不会在其它地方使用时，我们
         * 就应该选取使用匿名内部类的形式创建实例。
         */
        Comparator<Emp> com = new Comparator<Emp>(){ //Comparator 接口
            @Override
            public int compare(Emp o1, Emp o2) {
                return (int)(o1.salary - o2.salary);
            }
        };
        Collections.sort(e,com);
        System.out.println(e);
    }
}

class Emp{
    String name;
    int age;
    double salary;

    public Emp() {
    }

    public Emp(String name, int age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    @Override
    public String toString() {
        return name + " ," + age + " ," + salary;
    }
}

[Terry ,27 ,9000.0, Allen ,25 ,8000.0, Smith ,24 ,6500.0]
[Smith ,24 ,6500.0, Allen ,25 ,8000.0, Terry ,27 ,9000.0]

Process finished with exit code 0

队列和栈

1.队列的定义
游戏排队
在这里插入图片描述
2.队列的基本应用
在这里插入图片描述
队列基本应用

import java.util.LinkedList;
import java.util.Queue;

/**
 * 队列
 * 保存一组数组，在存取元素必须遵循先进先出原则
 * FIFO（First Input First Output）
 */
public class QueueDome {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<String>();
        /**
         * boolean offer(T t)
         * 入队方法
         * 将给定元素添加到队列队尾。添加成功返回true
         */
        queue.offer("A");
        queue.offer("B");
        queue.offer("C");
        queue.offer("D");
        System.out.println(queue); //[A, B, C, D]

        /*
         * T poll()
         * 用于获取队首元素，出队操作
         * 获取后，队列中将不再包含该元素
         */
        String str = queue.poll();
        System.out.println(str); //A
        System.out.println(queue);//[B, C, D]

        /*
         * T peek()
         * 用于获取队首元素，仅应用，不做出队操作
         */
        str = queue.peek();
        System.out.println(str);
        System.out.println(queue); //[B, C, D]

        /*
         * 遍历队列是一次性的
         */
        while (queue.size()>0){
            str = queue.poll();
            System.out.print(str + " "); //B C D 
        }
        System.out.println(queue);//[]
    }
}

3.双端队列
在这里插入图片描述
4.栈的基本操作
用处：文件系统
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

import java.util.Deque;
import java.util.LinkedList;

/**
 * 栈
 * 用于存储一组数据，存在元素必须遵循先进后出原则
 * 通常用于记录一组操作可追溯
 */
public class StatckDome {
    public static void main(String[] args) {
        Deque<String> stack = new LinkedList<String>();
        /*
         *void push(T t)
         * 向栈顶“压入”一个元素
         * 入栈操作
         */
        stack.push("A");
        stack.push("B");
        stack.push("C");
        stack.push("D");
        System.out.println(stack); //[D, C, B, A]

        /*
         *T pop()
         * 取出栈顶元素，出栈操作
         * 取出后，该元素会从栈中删除
         */
        String str = stack.pop();
        System.out.println(str); // D
        System.out.println(stack);//[C, B, A]

        str = stack.peek();
        System.out.println(str); //C
        System.out.println(stack);//[C, B, A]

        /*
         * 同样的，遍历栈也是一次性的
         */
        while (stack.size()>0){
            str = stack.pop();
            System.out.print(str + " ");//C B A
        }
        System.out.println(stack);//[]

    }
}

Map集合

在这里插入图片描述
1.Map集合常用方法
在这里插入图片描述

import java.util.HashMap;
import java.util.Map;

/**
 * Map
 * 该数据结构看起来更像是一个多行两列的表格
 * 每个数据中包含两个信息Key-value
 * 其中Key在Map中不允许重复，重复指的是equals为true
 *
 */
public class MapDome {
    public static void main(String[] args) {
        /*
         *创建一个Map
         * key是字符串，value是整数
         */
        Map<String,Integer> map = new HashMap<String,Integer>();
        /*
         * V put(K k,V v)
         * 将给定的Key与对应的value存入Map中
         * 若key在Map中不存在，则添加新内容
         * 那么返回值就是null
         * 若给定的Key在Map中已存在，则是替换value操作
         * 那么返回的是被替换的value值
         */
        System.out.println(map);//{}
        map.put("数学",115);
        map.put("语文",110);
        map.put("英语",110);
        map.put("物理",100);
        map.put("化学",95);
        map.put("生物",99);
        map.put("体育",90);
        map.put("体育",98);
        System.out.println(map);//{物理=100, 生物=99, 体育=98, 数学=115, 化学=95, 语文=110, 英语=110}

        /*
         * V get(K k)
         * 根据给定的key获取对应的value
         */
        Integer num = map.get("英语");
        System.out.println("英语：" + num);//英语：110
        /*
         * 给定一个Map中不存在的key返回值则为null
         */
       Integer num2 = map.get("高数");//注意是Integer
        System.out.println("高数：" + num2); //高数：null

        /*
         * boolean containsKey(K k)
         * 判断当前Map中是否包含给定的Key
         * 是否有根据Key的equals判断的
         */
        if(map.containsKey("数学")){//包含数学
            System.out.println("包含数学");
        }else{
            System.out.println("不包含数学");
        }

        /*
         * V remove(K k)
         * 根据给定的Key删除这一项
         * 返回值为删除的value
         * 若没有找到对应的Key,则返回值为null
         */
        System.out.println(map);//{物理=100, 生物=99, 体育=98, 数学=115, 化学=95, 语文=110, 英语=110}
        Integer remove = map.remove("化学");
        System.out.println(map);//{物理=100, 生物=99, 体育=98, 数学=115, 语文=110, 英语=110}
        System.out.println(remove);
    }
}

2.HashMap的原理
用处：适合大量数据查找
在这里插入图片描述
3.HashMap的应用
在这里插入图片描述
4.hashCode方法
在这里插入图片描述

import java.util.Objects;

/**
 * 重写equalse方法时应当重写hashCode方法
 * 重写规则如下：
 * 若两个对象equals方法比较结果为true，那么hashcode
 * 返回的数字必须相同
 * 若equals方法比较结果为false，他们的hashCode方法
 * 返回值应该尽量不同，否则影响HashMap性能
 * hashCode方法在当前对象内容没有发生改变的前提下多次
 * 调用应当返回相同的数字。
 */
public class Point {
    private int x;
    private int y;

    public Point() {
    }

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    public void setX(int x) {
        this.x = x;
    }

    public void setY(int y) {
        this.y = y;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Point point = (Point) o;
        return x == point.x &&
                y == point.y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }
}

hashCode队Map操作的影响

import java.util.HashMap;
import java.util.Map;

/**
 * hashCode队Map操作的影响
 */
public class MapDome2 {
    public static void main(String[] args) {
        Map<Point,Integer> map = new HashMap<Point,Integer>();

        Point p = new Point(1,2);
        map.put(p,100);
        boolean contains = map.containsKey(p);
        System.out.println("包含Key" + contains);//包含Keytrue
        System.out.println(map);//day05.Point@3e2=100

        Integer i = map.get(p);
        System.out.println(i);//100

        System.out.println(p.hashCode());//994
        //内容变化了，hashCode值就会变化
        p.setX(2);
        System.out.println(p.hashCode());//1025

        i = map.get(p);
        System.out.println(i);//根据新的hashCode查找 null
        System.out.println(p.getX());//2
        contains = map.containsKey(p);// 找不到Map
        System.out.println("包含p:" + contains);//false
        System.out.println(map);//day05.Point@401=100

        System.out.println(p.getX());//2
        map.put(p,200);
        System.out.println(map);//Point@401=200,Point@401=100

        map.remove(p);//删除 Point@401=200
        System.out.println(map);//Point@401=100

        p.setX(1);
        Integer ii = map.remove(p);
        System.out.println("删除的是：" + ii);
        System.out.println(map);

        /*
         *使用HashMap时应该注意：
         * 作为Key的对象有以下要求：
         * 1：首先Key这个类重写了equals方法，那么重写hashCode的要求必须满足
         * 2：作为Key的对象若存入HashMap后，其会影响HashCode值的内容不要发生改变，
         *    否则可能会影响Map的操作
         */

    }
}

5.HashMap性能调优
在这里插入图片描述

Map<Point,Integer> map = new HashMap<Point,Integer>(10000); // 3/4 初始16

Map的遍历

1.Map的遍历
在这里插入图片描述

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * 遍历Map的三种方式
 * 1：遍历所有的key
 * 2: 遍历所有的键值对（Key-value）
 * 3：遍历所有的value（不常用）
 */
public class MapDome3 {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<String,Integer>();
        map.put("数学",115);
        map.put("语文",110);
        map.put("英语",110);
        map.put("物理",100);
        map.put("化学",95);
        map.put("生物",99);
        map.put("体育",90);
        map.put("体育",98);

        /*
         * 遍历所有的key
         * Set><K> KeySet()
         * 该方法可以获取Map中所有的key，并将它们存入
         * 一个Set集合中返回
         * 所以，遍历该集合就等于遍历了所有的Key了
         */
        Set<String> keySet = map.keySet();
        for (String key: keySet){
            System.out.println("key: " + key);
        }

        /*
         * 遍历键值对
         * Set<Entry> entrySet()
         * 该方法会将每一组key-value存入一个Entry实例中，并将这些
         * Entry实例存入一个Set集合并返回
         * 我们只需要遍历该集合，拿到每个Entry实例
         * 并获取其中的key和value即可
         */
        Set<Map.Entry<String,Integer>> entrySet = map.entrySet();
        for(Map.Entry<String,Integer> e :entrySet){
            String key = e.getKey();
            Integer value  = e.getValue();
            System.out.println(key + ": " + value);
        }

        /*
         * 遍历所有的value
         */
       Collection<Integer> values =  map.values();
       for (Integer value: values){
           System.out.println(value);
       }
    }
}

key: 物理
key: 生物
key: 体育
key: 数学
key: 化学
key: 语文
key: 英语
物理: 100
生物: 99
体育: 98
数学: 115
化学: 95
语文: 110
英语: 110
100
99
98
115
95
110
110

2.Map常用应用场合
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

文件操作-file（新纪元）

在这里插入图片描述
查看文件周边信息

import java.io.File;

/**
 * java.io.File
 */
public class FileDome {
    public static void main(String[] args) {
        /*
         *用相对路径，相对当前项目的根目录 用 "."表示
         *
         * File.separator表示不同系统的目录层级分隔符
         * 为了忽略平台差异性，我们在写路径时应当使用
         * 该常量
         * 在windows表示 \\
         * 在linux表示//
         */
        File file =
                new File("."+File.separator +"Dome.txt");

        /*
         * String getNane()
         * 获取File表示的文件或者目录名字
         */
        String fileName =  file.getName();
        System.out.println(fileName);

        /*
         * boolean exists()
         * 判断当前File所表示的文件或目录是否真实
         * 存在
         */
        boolean exists = file.exists();
        System.out.println("是否真实存在：" + exists);

        /*
         * 创建文件不存在才可以创建
         */

        /*
         * long length()
         * 获取当前File所表示的文件所占用的字节量
         */
        long length = file.length();
        System.out.println("大小：" + length + "字节");

        /*
         * 查看当前File表示表示的文件是否具有可读，可写，可运行的权限
         */
        file.canRead();
        file.canWrite();
        file.canExecute();

        /*
         *获取当前文件或目录的最后修改时间
         */
        long time = file.lastModified();

        /*
         * boolean isFile()
         * 判断当前File对象表示的是否为一个文件
         */
         boolean isFile = file.isFile();
        System.out.println("是文件：" + isFile);

    }
}

创建一个空文件

import java.io.File;
import java.io.IOException;

/**
 * 使用File操作文件
 * 创建一个空文件
 */
public class FileDome2 {
    public static void main(String[] args) throws IOException {

        /*
         *当前项目的根目录下创建一个文件
         * test.txt
         */
        // 表示当前目录，可以忽略 "./"
        File file = new File("test.txt");
        if(!file.exists()){
            file.createNewFile();
            System.out.println("文件创建成功");
        }
        
    }
}

删除一个文件

import java.io.File;

/**
 * 删除一个文件
 */
public class FileDome3 {
    public static void main(String[] args) {
        /*
         *删除当前目录下的test.txt文件
         */
        File file = new File("test.txt");
        if(file.exists()){
            file.delete();
            System.out.println("删除成功");
        }
    }
}

使用File创建一个目录

import java.io.File;

/**
 * 使用File创建一个目录
 */
public class FileDome4 {
    public static void main(String[] args) {
        /*
         * 在当前目录下创建一个目录dome
         */
        File dir = new File("dome");
        if(!dir.exists()){
            dir.mkdir();
            System.out.println("创建目录成功");
        }
    }
}

删除一个目录

import java.io.File;

/**
 * 删除一个目录
 */
public class FileDome5 {
    public static void main(String[] args) {
        /*
         * 删除当前目录下的目录dome
         */
        File dir = new File("dome");
        boolean isDir = dir.isDirectory();
        System.out.println("是否为目录：" + isDir);
        if(dir.exists()){
            dir.delete();
            System.out.println("删除目录成功");
        }

    }
}

创建多级目录

import java.io.File;

/**
 * 创建多级目录
 */
public class FileDome6 {
    public static void main(String[] args) {
        /*
         * 当前目录下创建
         * a\b\c\d\e\f\g\h\i\j\k
         */
        File dir = new File("a\\b\\c\\d\\e\\f\\g\\h\\i\\j\\k");
        if(!dir.exists()){
            /*
             *mkdirs 方法在创建当前目录时，会自动
             * 创建所有不存在的父目录
             */
            dir.mkdirs();
            System.out.println("创建目录成功");
        }
    }
}
dlz0836
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
java se 1.8完整笔记，附大纲、代码、配图
07-23
java SE 1.8笔记大纲 java SE 1.8是 Java 编程语言的标准版，本笔记涵盖了Java SE 1.8的所有知识点，从基本数据类型到...本笔记涵盖了 Java SE 1.8 的所有知识点，是一个非常完整和系统的 Java 编程语言学习资源。
JAVA SE自学笔记.html
03-21
长期以来对Java的自学笔记长期以来对Java的自学笔记长期以来对Java的自学笔记长期以来对Java的自学笔记长期以来对Java的自学笔记长期以来对Java的自学笔记长期以来对Java的自学笔记长期以来对Java的自学笔记长期以来...
楠哥Java SE总结详细笔记
qq_42219004的博客
02-19 7116
Java SE总结 一、Java体系 1、Java 基础 1、跨平台 2、面向对象编程语言 3、分布式计算 2、Java 的运行机制 编程 Java 程序 编译 Java 文件 JVM 读取字节码文件运行程序 3、Java的三大体系 Java SE(J2SE) Java ME(J2ME) Java EE(J2EE) 4、配置 Java 环境 JRE、JDK JRE：Java Runtime Environment Java 运行环境 JDK：Java Devlopment K
狂神说java java基础篇 学习笔记
weixin_45975667的博客
03-29 1645
狂神说java java基础篇学习笔记，包括了狂神基础视频的所有内容
【JAVA】黑马程序员JAVA教程笔记 基础篇 Day 1
Summerison的博客
05-11 885
学习黑马程序员的新版JAVA教程视频所做的笔记。
黑马程序员Java笔记
m0_68735537的博客
03-14 1733
输出打印、参与运算、修改记录的值。
java最简单最全入门基础笔记(不简单，不全你打我)
热门推荐
javaboy_yl
11-11 14万+
刚开始学习java的时候，可能是一头雾水，不知道从何学起，这里跟大家分享一下!(仅仅只供初级学者学习，大佬勿喷) 一、初始java 1.生活中的程序： 从起床到教室上课的过程 穿衣打扮》起床》洗漱》出宿舍》》吃早餐》到教室 按照特定的顺序去完成某一件事的过程我们叫做生活中的程序 2.计算机中的程序: 一组有序指令的集合,需要和计算机交流就要使用计算机语言，java就是计算机语言的一种 3.java...
java se说明文档_Java笔记---Java官方API文档的下载及使用
weixin_39862484的博客
03-06 308
个人网站还在做数据迁移和备案，就先写在简书了(博客园将常被盗取)，但是知道为啥不能发布MarkdownJava 官方API文档官方文档即是最好的学习教材API文档是什么说明文档，用于说明每个类、每个方法的用途。当其他人使用一个类或一个方法时，可无需关心这个类或方法的实现，只需要关心这个类或方法的功能即可，然后使用这个类或方法来实现具 体的目的。也就是通过调用应用程序接口(API)来编程。...
Java基础笔记(韩顺平)已完结
wthsoso的博客
02-29 2070
Java零基础(韩顺平老师)基础笔记，复习可以从二维数组开始看起，若笔记有误请在评论区提出，感谢！
Java SE 学习笔记系列——开篇
y161101的博客
07-19 446
Java SE 学习笔记系列—— 开篇本系列笔记的来源本系列笔记讲解的主要知识 本系列笔记的来源 该笔记是作者对Java入门学习所作的笔记，作者所学习的书籍是由李兴华所出版的《Java开发实战经典》，该书通过通俗易懂的讲解以及加入大量的代码实例，让小白做到快速入门，从无到有的构建Java知识框架。若有对该书感兴趣的同学可以到某宝中购买。作者通过对该书的学习并加入了自己的理解，才总结出了本系列的学习...
【Java SE】Java基础学习笔记
NingHai's blog
11-04 264
Java学习笔记： 正文开始@Assassin Java基础语法 面向对象和多态 异常机制 泛型与集合类 Java I/O Java多线程 反射与注解
Java笔记（入门篇）
白豆五的博客
07-14 2629
为什么要使用Java？ 世界上最流行的编程语言之一，在国内使用最为广泛的编程语言。 可移植性(跨平台)、安全可靠、性能较好。 开发社区最完善、功能最丰富。
Java SE基础笔记总结
04-05
Java的一些笔记
Java-SE:Java 学习笔记，JAVA SE
05-18
这个学习笔记涵盖了Java SE的各个方面，对于初学者和有经验的开发者来说都是宝贵的资源。下面将详细介绍Java语言的基础知识、核心特性以及高级概念。 1. **Java语言基础** - **语法结构**：Java语言的语法基于C++...
golang 接口
m0_70982551的博客
07-24 815
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 367
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
【Java算法专场】二分查找(下）
最新发布
zhyhgx的博客
07-27 431
本道题是要在一个从0~n-1的数组中找缺失的数，我们可以采用哈希表来解决，但此时时空复杂度达到了O(n),这是一个有序的数组，我们可以采用二分查找来解决，使时间复杂度达到O(logn).我们可以发现，每个数组的下标和其元素是相同的，那么我们可以通过判断下标和元素的大小，来确定缺失值的位置。3.mid=4+(5-4)/2=4,nums[mid]=5
springboot之自动装配
weixin_50153914的博客
07-23 507
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

dlz0836

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值