Java笔记

Arrays

相关应用：冒泡排序

public class Main {
    public static void main(String[] args) {
                int[] arr={2,13,8,2,29};
                System.out.println("排序前："+arrayToString(arr));

                for(int j=0;j<arr.length-1;j++) {
                    for (int i = j+1; i < arr.length; i++) {
                        if (arr[j] > arr[i]) {
                            int temp = arr[j];
                            arr[j] = arr[i];
                            arr[i] = temp;
                        }
                    }
                }

                System.out.println("排序后："+arrayToString(arr));

    }

    private static String arrayToString(int[] arr) {
        StringBuilder sb=new StringBuilder();
        sb.append("[");//开头
        for(int i=0;i<arr.length;i++){
            if(i==arr.length-1){
                sb.append(arr[i]);
            }else{
                sb.append(arr[i]).append(",");
            }
        }
            sb.append("]");
        String s=sb.toString();
        return s;
    }
}

Array的概述和方法

有关排序：

public static String toString(int[] a);//返回指定数组的内容的字符表示形式
public static void sort(int[] a);//按照数字顺序排列指定的数组

相关实现：

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
                int[] arr={2,13,8,2,29};
                System.out.println("排序前："+Arrays.toString(arr));
                Arrays.sort(arr);
                System.out.println("排序后："+Arrays.toString(arr));
    }
}

注：Arrays属于工具类：1、构造方法用private修饰；2、成员用public static修饰

基本类型包装类

举例：

Integer类包装一个对象中的原始类型int的值，Integer.MIN_VALUE和Integer.MAX_VALUE

概述：用于数据类型与字符串之间的转换

基本数据类型       包装类
    byte          Byte
    short         Short
  *  int           Integer
    long          Long
    float         Float
    double        Double
  *  char          Character
    boolean       Boolean

Integer类的概述和使用

//已过时
public Integer(int value)//int对象
    eg.Integer i1=new Integer(100);//会输出100
public Integer(String s)//String对象（该字符串中，只能放数字）
    eg.Integer i2=new Integer("100");//会输出100
    eg.Integer i3=new Integer("abc");//会报错
//未过时
public static Integer valueOf(int i);//int对象
    eg.Integer i4=Integer.valueOf(100);//会输出100
public static Integer valueOf(String s);//String对象（该字符串中，只能放数字）
    eg.Integer i5=Integer.valueOf("100");//会输出100
    eg.Integer i6=Integer.valueOf("abc");//会报错

int和String的相互转换

相关方法：

//int转到String
int i;
//方式1-------->直接转换（不含有技术含量）
String s1=""+i;//空字符+数字
//方式2-------->调用函数：public static String valueOf(int i);
String s2=String.valueOf(i);

//String转到int
String s;
//方式1-------->间接转换：String->Integer->int
Integer i=Integer.valueOf(s);
int x=i.intValue();
//方式2-------->直接转换：调用函数public static int parseInt(String s);
int y=Integer.parseInt(s);

相关实现：

public class Main {
    public static void main(String[] args) {
        //int转到String
        int number=100;
        //1
        String s1=""+number;
        System.out.println(s1);
        
        //2
        //public static String valueOf(int i);
        String s2=String.valueOf(number);
        System.out.println(s2);
        System.out.println("--------------");
        
        
        //String转到int
        String s="100";
        //1：String->Integer->int
        Integer i=Integer.valueOf(s);
        //函数public int value();
        int x=i.intValue();
        System.out.println(x);
        
        //2：函数public static int parseInt(String s);
        int y=Integer.parseInt(s);
        System.out.println(s);
    }
}

案例：字符串中数据排序

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        String s="91 27 46 38 50";
        //得到字符串中每一个数字数据
        //调用函数public String[] split(String regex);
        String[] strArray=s.split("");//将字符串的各个数字分割开
        //放到int数组里面
        int[] arr=new int[strArray.length];
        for(int i=0;i<arr.length;i++){
            arr[i]=Integer.parseInt(strArray[i]);
        }
        //数组排序
        Arrays.sort(arr);
        //拼接为StringBuilder类型
        StringBuilder sb=new StringBuilder();
        for(int i=0;i<arr.length;i++){
            if(i==arr.length-1){
                sb.append(arr[i]);
            }else{
                sb.append(arr[i]).append(" ");
            }
        }
        //转换为String类型
       String result= sb.toString();
        //输出结果
        System.out.println("result "+result);
    }

}

自动装箱和拆箱

装箱：把基本数据类型转换为对应的包装类类型

拆箱：把包装类类型转换为对应的基本数据类型

Integer i=100;//自动装箱
i+=200;//相当于i=i+2  其中，i+200是自动拆箱，相当于ii.intValue()+200;
                      i=i+200是自动装箱，相当于赋值给Integer类型的i

注意：在使用包装类类型时，如果做操作，一定要先判断是否为null；即在使用前，必须进行不为null的判断；

日期类

Date类

1、获取当前时间(无参)

        Date d1=new Date();
        System.out.println(d1);

2、获取1970年的初始时间（带参）

        long date=1000*60*60;
        Date d2=new Date(date);
        System.out.println(d2);

Date类常用方法

public long getTime()；//获取时间差
public void setTime(long time);//设置时间

相关应用举例：

//获取时间差应用
Date d=new Date();
System.out.println(d.getTime());//获取从1970年零点到目前时间的毫秒值
System.out.println(d.getTime()*1.0/1000/60/60/24/365+"年")；//获取获取从1970年零点到目前时间的年份差值
    
//设置时间应用
    Date d=new Date();
long time=1000*60*60;
d.setTime(time);
System.out.println(d);//得到1970年的时间点
long time1=d.getTime();
d.setTime(time1);
System.out.println(d);//得到当前时间点
long time2=System.currentTimeMillis();
d.setTime(time2);
System.out.println(d);//得到当前时间点

SimpleDateFormat类

构造方法：

public SimpleDateFormat();//构造一个类，使用默认模式和日期格式-->无参
public SimpleDateFormat(String pattern);//使用给定的模式

1、格式化日期（Date到String）

//默认模式
Date d=new Date();
        SimpleDateFormat sdf=new SimpleDateFormat();
        String s=sdf.format(d);
        System.out.println(s);

//自定义模式
Date d=new Date();
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH：mm：ss");
        String s=sdf.format(d);
        System.out.println(s);

2、解析日期（String到Date）

 String ss="2022-07-20 17:20:13";
        SimpleDateFormat sdf2=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date dd=sdf2.parse(ss);
        System.out.println(dd);

注意：在解析日期时，要使得字符串与给定的模式相匹配，否则会报错！

案例：日期工具类

//DateTest.java
import java.text.ParseException;
import java.util.Date;

public class DateTest {
    public static void main(String[] args) throws ParseException {
        Date d=new Date();
        String s1=DateUtils.dateToString(d,"yyyy年MM月dd日 HH:mm:ss");
        System.out.println(s1);

        String s2=DateUtils.dateToString(d,"yyyy年MM月dd日");
        System.out.println(s2);

        System.out.println("---------------------");
        String s3="2022-07-20 17:45:23";
        Date  dd=DateUtils.stringToDate(s3,"yyyy-MM-dd HH:mm:ss");
        System.out.println(dd);
    }
}

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

public class DateUtils {
    //构造方法
    private DateUtils(){}
    //格式化日期方法
    public static String dateToString(Date date , String format){
        SimpleDateFormat sdf=new SimpleDateFormat(format);
        String s=sdf.format(date);
        return s;
    }
    //解析日期方法
    public static Date stringToDate(String s,String format) throws ParseException {
        SimpleDateFormat sdf=new SimpleDateFormat(format);
        Date d=sdf.parse(s);
        return d;
    }
}

Calendar类(抽象类)

多态形式获取年月日：

Calendar c=Calendar.getInstance();//多态的形式
        int year=c.get(Calendar.YEAR);              //年
        int month=c.get(Calendar.MONTH)+1;          //月
        int day=c.get(Calendar.DATE);               //日
//小时、分钟、秒并未列出,可依据上述推出
        System.out.println(year+"-"+month+"-"+day);

常用方法：

public int get(int field);//获取日历字段
public adstract void add(int field,int amount);//对时间进行加减运算
public final void set(int year,int month,int date);//设置当前的年月日

相关应用：

//2
//举例：10年后的10天前
Calendar c=Calendar.getInstance();
c.add(Calendar.YEAR,10);//正为后
c.add(Calendar.DATE,-10);//负为前
int year=c.get(Calendar.YEAR);
int month=c.get(Calendar.MONTH);
int date=c.get(Calendar.DATE);
//输出

//3
c.set(2023,12,12);//设置时间

案例：二月天

import java.util.Scanner;
import java.util.Calendar;
public class Main {
    public static void main(String[] args)  {
        Calendar c=Calendar.getInstance();
        Scanner sc=new Scanner(System.in);
        int year=sc.nextInt();//输入年份
        c.set(year,2,1);
        c.add(Calendar.DATE,-1);
        int day=c.get(Calendar.DATE);
        System.out.println(year+"年的2月有"+day+"天");
    }
}

异常

JVM的默认处理方案

异常处理

1、try...catch...

try{
可能出现异常的代码;
}catch(异常类名 变量名){
    异常的处理代码;
}

//应用
public class Main {
    public static void main(String[] args)  {
        System.out.println("开始");
        method();
        System.out.println("结束");
    }
public static void method(){
        try{
            int[] arr={1,2,3};
            System.out.println(arr[3]);
        }catch(ArrayIndexOutOfBoundsException e){
            //System.out.println("您访问的数组的索引不存在！");
            e.printStackTrace();
        }
}
}
//出现异常，能够正常运行到结尾

2、Throwable

public class Main {
    public static void main(String[] args)  {
        System.out.println("开始");
        method();
        System.out.println("结束");
    }
public static void method(){
        try{
            int[] arr={1,2,3};
            System.out.println(arr[3]);
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println(e.getMessage());//返回出现异常的原因，且能够正常运行到结束
            //System.out.println(e.toString());//返回更为详尽的原因
            e.printStackTrace();//报错原因最全
        }
}
}

编译时异常和运行时异常的区别

前者必须显示处理，否则程序无法运行；

后者无须显示处理，也可以和前者做一样的处理。

异常处理之throws

将异常抛出去;在抛出去之后，依旧需要try...catch...处理，才能继续运行错误后面的程序.

编译时异常必须进行处理，运行时异常可以不处理，后续可以进行修改代码的操作。

自定义异常

//格式
public class 异常类名 extends Exception{
    无参构造;
    带参构造;
}

应用举例：

//Main.java
public class Main extends Exception{
    public Main(){}
    public Main(String message){
        super(message);
    }
}

//DateTest.java
public class DateTest{
public void checkScore(int score) throws Main {
    if(score<0||score>100){
        throw new Main("你给的分数有误,分数应该在0-100之间");
    }else{
        System.out.println("分数正常");
    }
}
}

//DateUtils.java
import java.util.Scanner;

public class DateUtils {
    public static void main(String[] args) throws Main {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入分数：");
        int score=sc.nextInt();
        DateTest dt=new DateTest();
        dt.checkScore(score);
    }
}

throws和throw的区别

throws用在方法声明后面，跟的是异常类名、表示抛出异常，由该方法的调用者来处理、不一定会发生这些异常

throw用在方法体内，跟的是异常对象名、表示抛出异常，由体内语句处理、一定抛出了某些异常

集合体系结构

加一张图片

Collection集合

常用方法：

boolean add(E e);//添加元素
boolean remove(Object o);//从集合中移除指定的元素
void clear();//清空集合中的元素
boolean contains(Object o);//判断集合中是否存在指定元素
boolean isEmpty();//判断集合是否为空
int size();//集合的长度，也是集合中元素的个数

//可以添加相同的元素

相关用例：

Collection<String> c=new ArrayList<String>();
//添加
c.add("hello");
//移除
c.remove("hello");
//清空
c.clear();
//是否存在指定元素
System.out.println(c.contains("hello"));
//是否为空
System.out.println(c.isEmpty());
//获取集合长度
System.out.println(c.size());

Collection集合的遍历

Iteratoriterator();//返回此集合中元素的迭代器，通过集合的iterator()方法得到

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

public class Main {
    public static void main(String[] args) {
        //创建Collection集合的对象
       Collection<String> c=new ArrayList<String>();
        c.add("hello");
        c.add("world");
        c.add("world");

        Iterator<String> it=c.iterator();

        while(it.hasNext()){//判断是否存在
            System.out.println(it.next());
        }
    }
}

案例：Collection集合存储学生对象并遍历

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

public class Main {
    public static void main(String[] args) {
        //创建Collection集合的对象
       Collection<Student> c=new ArrayList<Student>();

       Student s1=new Student("zhangliang",19);
       Student s2=new Student("lili",18);
       Student s3=new Student("wangwu",20);

        c.add(s1);
        c.add(s2);
        c.add(s3);

        Iterator<Student> it=c.iterator();
        while(it.hasNext()){
            Student s=it.next();
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}

//Student.java
public class Student{
    private String name;
    private int age;
    public Student(){}
    public Student(String name,int age){
    this.name=name;
    this.age=age;
    }
     public void setName(String name){
        this.name=name;
     }

     public String getName(){
        return name;
     }

     public void setAge(int age){
        this.age=age;
     }

     public int getAge(){
        return age;
     }
}

List集合（有序、允许重复）

基本操作：

import java.util.*;

public class Main {
    public static void main(String[] args) {
       List<String> l=new ArrayList<String>();

       l.add("hello");
       l.add("world");
       l.add("hello");
       l.add("java");

        Iterator<String> it=l.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

特有方法：(上级Collection没有，但下级ArrayList有);

void add(int index,E element);//在指定位置插入指定元素
E element(int index);//删除指定处的元素
E set(int index,E element);//修改指定位置处的元素
E get(int index);//返回指定索引处的元素
E size();//得到List长度

相关应用：

//特定位置添加
ll.add(1,"fighting");//位置的指定需要在List长度范围内
//移除特定位置的元素
ll.remove(1);//位置的指定需要在List长度范围内
//修改指定位置的元素
ll.set(1,"iam");//位置的指定需要在List长度范围内
//返回指定索引处的元素
System.out.println(ll.get(1));//位置的指定需要在List长度范围内
//利用迭代器实现遍历
Iterator<String> it=ll.iterator();
//1
while(it.hasNext()){
    System.out.println(it.next());
}
//2
for(int i=0;i<ll.size();i++){
    String s=it.next();
    System.out.println(s);
}

案例：List集合存储学生对象并遍历

//Main.java
import java.util.*;

public class Main {
    public static void main(String[] args) {
       List<Student> ll=new ArrayList<Student>();
       Student s1=new Student("zhangliang",19);
        Student s2=new Student("lili",18);
        Student s3=new Student("wangwu",20);
        ll.add(s1);
        ll.add(s2);
        ll.add(s3);

        Iterator<Student> it=ll.iterator();
        for(int i=0;i<ll.size();i++){
            Student s=it.next();
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}

//Student.java
public class Student{
    private String name;
    private int age;
    public Student(){}
    public Student(String name,int age){
    this.name=name;
    this.age=age;
    }
     public void setName(String name){
        this.name=name;
     }

     public String getName(){
        return name;
     }

     public void setAge(int age){
        this.age=age;
     }

     public int getAge(){
        return age;
     }
}

并发修改异常

通过迭代器遍历的过程中，里面会出现由于进行判断，会出现预期修改的值和实际修改的值不一样的情况------>报错。

解决：

//不使用迭代器
for(int i=0;i<ll.size();i++){
    String s=ll.get(i);
    if(s.equals("world")){
        ll.add("javaee");
    }
}

ListIterator-->列表迭代器

//正向
List<String> ll=new ArrayList<String>();
        ll.add("hello");
        ll.add("world");
        ll.add("java");
//列表迭代器需要在List下完成
ListIterator<String> lit=ll.listIterator();
        while(lit.hasNext()){
            String s=lit.next();
            System.out.println(s);
        }
        System.out.println("---------------");
        while(lit.hasNext()){
            String s=lit.next();
            System.out.println(s);
        }
//反向
List<String> ll=new ArrayList<String>();
        ll.add("hello");
        ll.add("world");
        ll.add("java");
        ListIterator<String> lit=ll.listIterator();
        while(lit.hasNext()){
            String s=lit.next();
            System.out.println(s);
        }
        System.out.println("---------------");
        while(lit.hasPrevious()){
            String s=lit.previous();
            System.out.println(s);
        }

//判断添加--->ListIterator迭代器被允许
while(lit.hasNext()){
            String s=lit.next();
            if(s.equals("world")){
                lit.add("javaee");
            }
        }

增强for循环(简化遍历)

其内部是一个iterator迭代器

for(元素数据类型变量名:数组或者Collection集合){
    //在此处使用变量即可，该变量就是元素
}

举例：

//int类型
int[] arr={1,2,3,4,5};
        for(int i:arr){
            System.out.println(i);
        }
//String类型
        String[] strarray={"hello","world","java"};
        for(String i:strarray){
            System.out.println(i);
        }
//List类型
List<String> ll=new ArrayList<String>();
        ll.add("hello");
        ll.add("world");
        ll.add("java");
        for(String s:ll){
            System.out.println(s);
        }

案例：List集合用增强for循环存储学生对象并遍历

//Main.java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<Student> ll=new ArrayList<Student>();
        Student s1=new Student("zhangliang",19);
        Student s2=new Student("lili",18);
        Student s3=new Student("wangwu",20);
        ll.add(s1);
        ll.add(s2);
        ll.add(s3);
        for(Student s:ll){
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}

//Student.java
public class Student{
    private String name;
    private int age;
    public Student(){}
    public Student(String name,int age){
    this.name=name;
    this.age=age;
    }
     public void setName(String name){
        this.name=name;
     }

     public String getName(){
        return name;
     }

     public void setAge(int age){
        this.age=age;
     }

     public int getAge(){
        return age;
     }
}