java基础部分

最新推荐文章于 2024-08-12 15:45:48 发布

退役熬夜冠军选手

最新推荐文章于 2024-08-12 15:45:48 发布

阅读量233

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_41893646/article/details/109430242

版权

第一章创建对象

1.1 java包管理器

导入包的语句：import 包名+类名
例如：在计算机磁盘内的路径java/time/LocalDate.java

import java.time.LocalDate;

我们来看一下 LocalDate这个日期类：
日期时间和字符串的转化：

import java.time.LocalDate;                    //日期类
import java.time.format.DateTimeFormatter;    //日期格式化类

public class DateTest5 {

  public static void main(String[] args) {

    LocalDate time = LocalDate.now();
    // 打印默认的时间数据
    System.out.println(time.toString());

    // 创建一个格式化方式
    DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy年MM月dd"); 
// DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy/MM/dd");  也可以转化为这种格式
    // 执行时间的格式化处理，得到期望格式的时间字符串
    String timeStr = df.format(time);
    // 打印时间
    System.out.println(timeStr);

  }
}

获取日期时间具体的值:

import java.time.LocalDate;

public class DateTest7 {

  public static void main(String[] args) {

    LocalDate time = LocalDate.now();

    // 得到当前时间所在年
    int year = time.getYear();
    System.out.println("当前年份 " + year);

    // 得到当前时间所在月
    int month = time.getMonth().getValue();
    System.out.println("当前月份 " + month);

    // 得到当前时间在这个月中的天数
    int day = time.getDayOfMonth();
    System.out.println("当前日 " + day);

    // 得到当前时间所在星期数
    int dayOfWeek = time.getDayOfWeek().getValue();
    System.out.println("当前星期 " + dayOfWeek);

  }
}

1.2 日期时间类的运用

字符串转化为日期时间

import java.time.LocalDate;

public class DateTest8 {

  public static void main(String[] args) {
    // 定义一个时间字符串，日期是2019年1月1日
    String date = "2019-01-01";

    // 把字符串转化位 LocalDate 对象，并得到字符串匹配的日期
    LocalDate date2 = LocalDate.parse(date);   //字符串转换为LocalDate对象    2019-01-01
    // 打印出日期
    System.out.println(date2.toString());
  }
}

如果日期字符串的格式不是yyyy-MM-dd,那么就要借助 DateTimeFormatter

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

public class DateTest81 {

  public static void main(String[] args) {
    // 定义一个时间字符串，日期是2019年1月1日
    String date = "2019/01/01";

    DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy/MM/dd");

    // 把字符串转化位 LocalDate 对象，并得到字符串匹配的日期
    LocalDate date2 = LocalDate.parse(date,df);
    // 打印出日期
    System.out.println(date2.toString());
  }
}

日期时间的计算

import java.time.LocalDate;
public class DateTest10 {
  public static void main(String[] args) {
    LocalDate now = LocalDate.now();
    System.out.println("当前：" + now.toString());
    System.out.println("加法运算");
    System.out.println("加1天：" + now.plusDays(1));
    System.out.println("加1周：" + now.plusWeeks(1));
    System.out.println("加1月：" + now.plusMonths(1));
    System.out.println("加1年：" + now.plusYears(1));
    System.out.println("减法运算");
    System.out.println("减1天：" + now.minusDays(1));
    System.out.println("减1周：" + now.minusWeeks(1));
    System.out.println("减1月：" + now.minusMonths(1));
    System.out.println("减1年：" + now.minusYears(1));
  }
}

两个日期时间先后的判断

import java.time.LocalDate;
public class DateTest11 {
  public static void main(String[] args) {
    LocalDate now = LocalDate.now();
    // 可以对两个 LocalDate 进行比较，
    // 可以判断一个日期是否在另一个日期之前或之后，
    // 或者判断两个日期是否是同年同月同日。
    boolean isBefore = now.minusDays(1).isBefore(LocalDate.now());
    System.out.println("是否在当天之前：" + isBefore);
    boolean isAfter = now.plusDays(1).isAfter(LocalDate.now());
    System.out.println("是否在当天之后：" + isAfter);
    // 判断是否是当天
    boolean sameDate = now.isEqual(LocalDate.now());
    System.out.println("是否在当天：" + sameDate);
  }

}

1.3 面向对象–抽象

在java中一切皆对象，任何事物都可以抽象为一个java对象，就像我们把房子抽象为户型图一样
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L8BiUQak-1604220250740)(https://style.youkeda.com/img/ham/course/j1/j1-8/hourse-design.svg)]
创建java文件的四个规范： 1 文件名由类名+.java组成
2 类名遵循大驼峰的命名方式
3 内容遵守固定格式
4 默认情况下文件存放在src/main/java目录中

public class 类名称 {}  //内容格式

1.4 面向对象–属性和方法

完整的抽象过程包括抽象对象名称，对象属性，对象方法。

public void turnLightsOn(){} //打开灯的方法  没有static关键字是对象方法，如果有static关键字是静态方法

实例化对象
对象的属性和方法必须要先实例化之后才能使用，实例化的方法很简单，我们以house为例子

//我的房子
House myHouse = new House();
//你的房子        
House youHouse = new House();     //youHouse.turnLightsOn(); 实例化后调用方法
//她的房子
House herHouse = new House();    // herHouse.color = "red"; 实例化后调用属性

构造函数：是一个比较特别的对象方法无参构造函数实例化时无参，有参实例化时要带有参数。

new 构造函数();//实例化的细节

 public class House{                    //这就是默认的构造函数
     public House(){
     }
 }

它的名称和类名一模一样
构造函数没有返回值
构造函数一般配合实例化对象一起使用，可以把构造函数当初类对象的初始化方法。

带参数构造函数

public class House {
    // 房子的颜色是绿色
    public String color = "green";

    // 自定义一个带 color 参数的构造函数
    public House(String color){
      this.color = color;                    //注意这个this 代表的是实例化后的对象
    }
}

显示指定默认构造函数，如果java中定义了新的构造函数，那么默认的无参构造函数就会失效。

1.5 ArrayList

ArrayList语法：是一个动态数组对象，可以方便的存储集合对象（一般存放同类型的数据），使用前需要实例化。

// 这里的 Java 对象类型可以是任意的对象类型
// 比如 String、Integer、House 等
// 这里的 <> 是 Java 泛型的规范,记住这个语法就行了
ArrayList<Java 对象类型> list = new ArrayList<>();

使用add方法进行数据的添加

import java.util.ArrayList;
public class ArrayListTest1{
  public static void main(String[] args){
    // 创建一个 ArrayList 存储字符串集合
    ArrayList<String> strs = new ArrayList<>();
    // 添加数据到 ArrayList 实例里
    strs.add("张三");
    strs.add("李四");
  }
}

get/set方法
ArrayList是动态数组，遵循动态数组的特点：
1 可以获取长度.size（）
2 可以根据索引获得具体的值

import java.util.ArrayList;
public class ArrayListTest1{
  public static void main(String[] args){
    // 创建一个 ArrayList 存储字符串集合
    ArrayList<String> strs = new ArrayList<>();
    // 添加数据到 ArrayList 实例里
    strs.add("张三");
    strs.add("李四");
    // 获取集合的长度
    int size = strs.size();
    // 使用 for 循环迭代每一条记录
    for(int i=0;i<size;i++){
       // 根据索引获取值，值的类型是 String
       String str = strs.get(i);
       System.out.println(str);
    }
  }
}

for语句：

for(String str : strs){        //for( 集合变量的类型 变量名称 : 集合变量 )       变量名称可以是任意字符串
       System.out.println(str);
    }

第二章 java面向对象

2.1 类的关联关系封装和常量

抽象是编程思维里面最核心的一点，它就是把事物变成变成编程语言的过程。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JpLpLL3u-1604220250743)(https://style.youkeda.com/img/ham/course/j2/chouxiang1.svg)]
ID主键用于表示全局唯一的纪录。
对象的特性：
1所有事物都可以抽象为对象
2 对象是唯一的
3 对象具备属性和方法

类之间的关系：关联依赖聚集泛化实现

封装：把类的属性隐藏起来，只能通过公开的方法来得到或者设置属性值，现在业内是get set规范。

变量作用域：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rgEQJFFM-1604220250745)(https://style.youkeda.com/img/ham/course/j2/setter2.svg)]
注意这里的this就是实例化后的对象，通过this我们可以调用实例内的方法和属性。
方法内的变量是不允许使用修饰符，变量名也不可以重复

public void say(String name){
  // 这个 private 是错误的
  private String msg = "hello";
  // 这个 name 变量名是错误的，因为重复了
  String name = "a";
  int age = 18;
  // 这个字符串 age 变量名是错误的，因为重复了
  String age = "18岁";
}

常量：静态变量
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8v7RemW9-1604220250748)(https://style.youkeda.com/img/ham/course/j2/static1.svg)]
常量可以直接获取或者操作变量而不需要实例化：因为java为它创建了一个全局唯一的内存空间。
常量的变量名一般全部大写来和变量区分，常量一般用在：
1 常用的字符串

/*** 用户Session key*/
public static final String USER_KEY = "m_key";      //final final 代表着这个变量不可以被再次修改用来保证代码安全。
/** * 手机验证码 key*/
public static final String SMS_KEY = "m_sms_key";

2 需要在内存中做缓存值：缓存一些数据到内存中提高计算机的性能

package com.youkeda.service;
import com.youkeda.model.School;
/**
 * 学校服务
 */ 
public class SchoolService{
  // 学校数据的常量
  public static ArrayList<School> SCHOOLS = new ArrayList<>();  
  // 声明一个静态代码块，用于初始化学校数据
  static{
    School school = new School();
    school.setId("1");
    school.setName("北京大学");
    SCHOOLS.add(school);
    school = new School();
    school.setId("2");
    school.setName("清华大学");
    SCHOOLS.add(school);
  }
  public static void main(String[] args){
    // 测试打印一下内存的数据
    for(int i=0;i<SCHOOLS.size();i++){
      School school = SCHOOLS.get(i);
      System.out.println(school.getName());
    }
  }
}

2.2 继承和修饰符

继承：当我们遇到具备相同属性，从属某一类别，领域的对象时，就可以使用继承。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JNPrSjtW-1604220250750)(https://style.youkeda.com/img/ham/course/j2/extends.svg)]
语法：在创建类的时候，使用extends关键字即可上图表示dog继承animal dog是animal的子类，animal称为父类。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pRkVcgyO-1604220250751)(https://style.youkeda.com/img/ham/course/j2/dog2.svg)]
public protected修饰的父类子类可以获取父类的变量和方法，private的则不可以。

修饰符：
公开级别：用 public 修饰，对外公开
受保护级别：用 protected 修饰，向子类及同一个包中的类公开
默认级别：没有访问修饰符，向同一个包中的类公开
私有级别：用 private 修饰，只有类本身可以访问，不对外公开

方法覆盖：子类重写父类定义的方法当调用父类方法的时候，可以直接执行子类的方法

package com.youkeda.model;
public class Dog extends Animal{
    public void eat(){
        System.out.println("狗狗喜欢吃肉骨头");
    }
}

Animal d = new Dog();              //子类的对象可以转化为父类的对象
Dog dog = new Animal()             //这个用法是错误的

super关键字：super只发生在子类中，调用父类的方法。

public class Dog extends Animal{
    public void eat(){
        // 调用父类的方法
        super.eat();                   //父类有一些通用的逻辑时
        System.out.println("狗狗喜欢吃肉骨头");
    }
}

子类的构造函数：当父类只有一个有参数的构造函数时，子类也必须要具备这个有参构造函数，或者使用super方法，构造新的构造函数。

public class JavaFile extends CustomFile{        //具备和父类相同的构造函数
  // 声明一个构造函数
 public JavaFile(String filePath){
    super(filePath);
  }
}

public class JavaFile extends CustomFile{                    //声明一个新的构造函数
  private String packageName;
  // 声明一个构造函数
  public JavaFile(String filePath,String packageName){
    super(filePath);                                         //super关键字放在第一行
    this.packageName = packageName;
  }
  public String getPackageName(){
      return this.packageName;
  }
}

2.3 接口

接口（interface）:接口是一个类，也包括方法，它可以支持多个实现类。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qMaUbFJk-1604220250752)(https://style.youkeda.com/img/ham/course/j2/LoginService.svg)]
在uml中，接口的图标是它的类以service结尾。

接口实现类：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-A7reldrl-1604220250754)(https://style.youkeda.com/img/ham/course/j2/implements.svg)]
接口中的方法实现类中必须要有，且修饰符都是public
实现类可以实现多个接口：

package com.youkeda.service.impl;
import com.youkeda.service.RoleService;     
import com.youkeda.service.EchoService;
public class RoleServiceImpl 
             implements RoleService,EchoService{            //实现两个接口，用逗号隔开
    public void addRole(Role role){
    }
    public ArrayList<Role> getRoles(){
        return null;
    }
    public void echo(){
    }
}

接口的实例化：结合实现类的实例化

RoleService roleService = new RoleServiceImpl();     //实例化接口

// 类型转化：把 roleService 实例转化为 EchoService 接口类型     
 EchoService echoService = (EchoService)roleService;

java常用接口：Map和List 这两个都是具体的数据结构
java开发中的核心之一：用接口来定义对象的属性和方法
Map:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uegJ3Xor-1604220250755)(https://style.youkeda.com/img/ham/course/j2/java-map1.png)]
Map是key:value这样形式的集合，它的实现类之一是HashMap

import java.util.Map;
import java.util.HashMap;
// key value 得是 Java 类型
Map<key,value> map = new HashMap<>();       //得到Map的实例

可以使用map.put()存入数据，然后用map.get()取出数据

// 实例化Map对象
Map<Integer,String> map = new HashMap<>();    //key的类型是Integer,value的类型是String

map.put(1,"Monday");                         //存入数据
map.put(2,"Tuesday");
map.put(3,"Wednesday");
map.put(4,"Thursday");
map.put(5,"Friday");
map.put(6,"Saturday");
map.put(7,"Sunday");

String weekText = map.get(3);                //取出数据
System.out.println(weekText); 

int size = map.size();                       //集合大小
System.out.println(size);

for (Map.Entry<Integer,String> entry : map.entrySet()){    //map的遍历
   System.out.println("Key = " + entry.getKey() + 
                  ", Value = " + entry.getValue());
 }

List:它是ArrayList的接口，用法和ArrayList相似。
储存字符串集合

List<String> strings = new ArrayList<>();

for(String str : strings){                      //List的遍历
    System.out.println(str);
}

2.4 java的异常机制

bug：程序错误
一般错误分为：编译错误语法错误，新手较常见
运行错误（异常）运行时出现的错误，异常是可以被捕获和处理的。
异常机制：通过异常机制，我们即使部分出问题，也不会影响其他部分的运行。java把异常定义为类，不同的异常可以用不同的方式处理。
异常流程和正常流程是分离的，一旦某段程序抛出了异常，这段代码如果有能力处理，就捕获它，否则只需抛出异常由调用者来处理。
捕获异常：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QWh3Qb2B-1604220250757)(https://style.youkeda.com/img/ham/course/j2/ExceptionTest2.svg)]

java的异常类：

从上图我们可以看出异常Exception和错误error都是继承于throwable，异常类一般都以Exception结尾。
常见的异常类：

IOException：操作输入流和输出流时可能出现的异常

ArithmeticException： 数学异常。如果把整数除以0，就会出现这种异常
                      int a=12/0; // 抛出ArithmeticException

NullPointerException:空指针异常。当引用变量为null时，试图访问对象的属性或方法，就会出现这种异常，例如：
                     String d = null;
                     System.out.println(d.length()); // 抛出NullPointerException

ArrayIndexOutOfBoundsException2:下标越界异常,一般出现在数组中，比如
                       int[] array = new int[4];
                       array[0]=1;
                       array[7]=1;// 抛出 ArrayIndexOutOfBoundsException

ClassCastException1  当类型转化失败的时候就会出现该异常

IllegalArgumentException2非常参数异常，可以用来检查方法的参数是否合法

多个异常的捕获：可以单独根据异常类来捕获，也可以用Exception捕获（建议直接用Exception）

public class ExceptionTest4 {
    public static void main(String[] args) {
        int num = 0;
        try {
          num = getInt("小王");
        } catch (Exception e) {             //用Exception捕获异常
        }
        System.out.println(num);
    }
    // 字符串转换为数字
    public static int getInt(String str) {
        return Integer.parseInt(str);
    }

}

抛出异常：多数异常是系统抛出的，我们自己也可以手动抛出异常。
手动抛出：在需要抛出的地方使用throw关键字

public static int getInt(String str){
    if(str == null){
        throw new IllegalArgumentException("姓名不能为空");  //使用throw关键字
    }
    return Integer.parseInt(str);
}

异常的显示叫做异常堆栈，仔细阅读可以发现许多有用信息

Caused by: java.lang.IllegalArgumentException: 姓名不能为空
    at ExceptionTest5.getInt(ExceptionTest5.java:11)
    at ExceptionTest5.main(ExceptionTest5.java:5)
    ... 76 more

我们经常使用如下方式抛出异常：一先捕获异常
二声明异常

public class ExceptionTest8 {

    public static void main(String[] args) {
        int num = 0;
        try {
            num = getInt(null);
        } catch (Exception e) {                                //捕获异常
            System.out.println(e.getMessage());
        }
        System.out.println(num);
    }
    public static int getInt(String str) throws Exception {    //声明异常
        if (str == null) {
            throw new Exception("姓名不能为空");                  //抛出异常
        }
        return Integer.parseInt(str);
    }
}

我们来看一个uml图表示的异常
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BhPfR3g7-1604220250758)(https://style.youkeda.com/img/ham/course/j2/UserServiceException.svg)]

package com.youkeda.service;
public interface UserService {
  User login(String userName,String password) throws NullPointerException;
}

自定义异常：有时候java系统定义的异常不能满足我们的业务需求，需要我们自己定义异常的类型。

public class ParamNullException extends Exception {           //只需要继承于Exception 即可
}

此异常的实现类

public User login(String userName, 
                  String password) throws ParamNullException {
  if (userName == null || password == null) {
    throw new ParamNullException();
  }
  for (User user : USERS) {
    if (user.getUserName().equals(userName) && user.getPassword().equals(password)) {
        return user;
    }
  }
  return null;
}

自定义异常的构造函数：

public class ParamNullException extends Exception {
  public ParamNullException() {                  //空的构造函数，必须要创建
  }
  public ParamNullException(String msg) {
    super(msg);
  }
}

finally：它一般和try一起使用，使得系统更加安全
示例：使发生异常的时候关门

public void work() throws LeaveEarlyException {
    try {
      开门
      工作 8个小时 // 可能会抛出异常 DiseaseException
      关门
    } catch (DiseaseException e){
      throw new LeaveEarlyException();
    } finally{
      关门
    }
}

第三章内部类 java对象和集合

3.1 内部类

面向对象的核心思想之一就是封装，我们在对变量属性的封装之外，还可以在某一个类中定义一个属于它的内部类来封装一些服务。

内部类的语法和实例化（使用前必须先实例化，且内部类不能有静态变量）：

package com.youkeda.util;

public class OuterUtil {                                        // 外部类
    public class InnerTool {                                   // 内部类
        public int add(int a,int b){
            return a+b;
        }
    }
    private InnerTool tool = new InnerTool();                  //内部类的实例化
}

uml[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JRfHwmj1-1604220250759)(https://style.youkeda.com/img/ham/course/j2/InnerTool.svg)]
在使用时，我们只实例化外部类，然后调用方法，并不会感知到内部类的存在。
由于访问其他内的内部类比较麻烦（需要先实例化外部类如下图），所以我们并不建议直接访问内部类

OuterUtil.InnerTool tool = new OuterUtil().new InnerTool();

静态内部类：添加static关键字静态内部类可以直接被调用而不需要实例化外部类。

package com.youkeda.util;
public class OuterUtil {
    public static class InnerTool {             // 静态内部类
        public int add(int a,int b){
            return a+b;
        }
    }
}


package com.youkeda.test;
import com.youkeda.util.OuterUtil;
// 静态内部类是需要单独 import 的
import com.youkeda.util.OuterUtil.InnerTool;
public class OuterUtilTest {
   public static void main(String[] args){
       InnerTool tool = new InnerTool();          //可以直接实例化调用
       int sum = tool.add(1,2);
       System.out.println(sum);
   }

}

局部内部类：在方法中定义一个类，用的比较少，多见于框架中。

匿名类：本质上是一个局部内部类，但是只用于类的实例化，而不是声明。

public class ATest {
  public static void main(String[] args){
    A a = new A(){                      //用于类的实例化 
       public void method(){
         System.out.println("执行内部类");
       }
    };
    a.method();
  }
}

上面等同于
public class AImpl implements A{
  public void method(){
    System.out.println("执行类");
  }
}

匿名类除了实现接口之外，还可以继承父类

public class Sub {
  public void print(){
  }
}

public class SubTest {
  public static void main(String[] args){
    Sub sub = new Sub(){
       public void print(){
         System.out.println("执行内部类");
       }
    };
    sub.print();
  }
}

上面的效果等同于
public class SubNode extends Sub {
  public void print(){
    System.out.println("执行");
  }
}

接口中的默认方法：
抽象类是一个父类，它的实例化须要有子类参与，当然也可以通过匿名类实例化。
示例：

// 定义一个武器的抽象类
public abstract class Weapon{         //abstract关键字需要在类上声明
  // 抽象方法：攻击
  public abstract void attack();     //abstract关键字需要在方法上声明
} 

它的子类
public class GoldenBar extends Weapon {
  public void attack(){
    System.out.println("使用金箍棒进行劈一棍"); //必须要有父类的方法
  }
}

uml图[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TI7TQpp7-1604220250761)(https://style.youkeda.com/img/ham/course/j2/weapon.svg)]

在接口中某个方法上使用defalut关键字，可以使实现类中不一定要覆盖该方法。

public interface Vehicle {
   default void print(){                   //接口方法上的default关键字
      System.out.println("我是一辆车!");         
   }
}

覆盖接口上的默认方法
public class Car implements Vehicle {
   public void print(){
      System.out.println("我是一辆汽车!");
   }
}

不覆盖接口的默认方法
public class Car implements Vehicle {
}

###3.2 对象的关系
聚合关系（Aggregation)：聚合是一种特殊的关联(Association)形式，表示两个对象之间的所属(has-a)关系。所有者对象称为聚合对象，它的类称为聚合类；
从属对象称为被聚合对象，它的类称为被聚合类
uml[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8xBaAUUx-1604220250762)(https://style.youkeda.com/img/ham/course/j2/aggregation.svg)]

示例：公司类和员工类
public class Company {
    private List<Employee> employees;
}

public class Employee {
    private String name;
}

组合关系(Composition):聚合是一种较弱形式的对象包含(一个对象包含另一个对象)关系，较强形式是组合(Composition)。在组合关系中包含对象负责被包
含对象的创建以及生命周期，即当包含对象被销毁时被包含对象也会不复存在
uml[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-drjTMmk6-1604220250763)(https://style.youkeda.com/img/ham/course/j2/composition.svg)]

依赖关系(Dependency):依赖(Dependency)描述的是一个类的引用用作另一个类的方法的参数
uml[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FP6VimoP-1604220250764)(https://style.youkeda.com/img/ham/course/j2/dependency.svg)]

继承(Inheritance)/实现(Realization)关系:继承和实现的 UML 图是一样的表达了子类继承父类，实现类实现接口的关系.
uml[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zIaXRywA-1604220250765)(https://style.youkeda.com/img/ham/course/j2/bar.svg)]

3.3 java集合

List和数组的互换：

数组转化为List
Arrays 是一个工具类，所以它的方法都是静态方法，我们先了解最常用的转化方法。
static List asList(T… a)示例

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

public class ArraysMain {
 public static void main(String[] args) {
   // 转化数组为 list
   List<String> lists = Arrays.asList("小王","小明");   //参数为对象数组，不为基本数组
   System.out.println("集合的长度是: " + lists.size());

   // 转化数组为 list2
   List<String> lists2 = Arrays.asList("小王","小明","小李"); //参数为对象数组，不为基本数组
   System.out.println("集合2的长度是: " + lists2.size());
 }
}

List转化为数组：使用toArray方法即可

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

public class List2ArrayTest {
    public static void main(String[] args)
    {
        List<Integer> al = new ArrayList<Integer>();
        al.add(10);
        al.add(20);
        al.add(30);
        al.add(40);

        // 转化为数组
       Integer[] arr = al.toArray(new Integer[]{});  //使用toArray方法即可
        for (Integer x : arr) {
          System.out.println(x + " ");
        }
    }
}

List集合转化为字符串：使用String.join(“split”,list)方法。

  String string = String.join(",", list);  //转化为字符串并用逗号分割

排序
Arrays.sort()：java.util.Arrays 这个工具类非常强大，它的 sort 方法就可以实现数字的排序，默认它的排序是从小到大的顺序排序

Arrays.toString 的方法签名如下：任何数组数字都可以转化为字符串

public static String toString(boolean[] arr)
public static String toString(byte[] arr)
public static String toString(char[] arr)
public static String toString(double[] arr)
public static String toString(float[] arr)
public static String toString(int[] arr)
public static String toString(long[] arr)
public static String toString(Object[] arr)
public static String toString(short[] arr)

import java.util.*;

public class Arrays2String {
   public static void main(String[] args) {
        boolean[] boolArr = new boolean[] { true, true, false, true };
        byte[] byteArr = new byte[] { 10, 20, 30 };
        char[] charArr = new char[] { 'g', 'e', 'e', 'k', 's' };
        double[] dblArr = new double[] { 1, 2, 3, 4 };
        float[] floatArr = new float[] { 1, 2, 3, 4 };
        int[] intArr = new int[] { 1, 2, 3, 4 };
        long[] lomgArr = new long[] { 1, 2, 3, 4 };
        Object[] objArr = new Object[] { 1, 2, 3, 4 };
        short[] shortArr = new short[] { 1, 2, 3, 4 };

        System.out.println(Arrays.toString(boolArr));
        System.out.println(Arrays.toString(byteArr));
        System.out.println(Arrays.toString(charArr));
        System.out.println(Arrays.toString(dblArr));
        System.out.println(Arrays.toString(floatArr));
        System.out.println(Arrays.toString(intArr));
        System.out.println(Arrays.toString(lomgArr));
        System.out.println(Arrays.toString(objArr));
        System.out.println(Arrays.toString(shortArr));
    }
}

自定义排序：static void sort(T[] a, Comparator< super T> c):

我们可以在第二个参数里传递自定义比较类来确定排序，java.util.Comparator是一个接口，用于声明比较规则一般配合排序一起使用，
我们看一下这个接口的方法
public interface Comparator {
//返回值是 int，我们根据返回值 >0、=0、<0 进行重新排序
int compare(T o1, T o2);
}
示例：

import java.util.*;
public class ArraysSortTest2 {
    public static void main(String[] args) {
        Integer[] intArr = { 10, 20, 15, 22, 35 };
        // 自定义排序
        Arrays.sort(intArr, new Comparator<Integer>(){
            public int compare(Integer o1, Integer o2){
                
                return o2-o1;  //根据返回值的正负来进行排序 正升序 负倒序
            }
        });
        System.out.println("Integer Array: "
                           + Arrays.toString(intArr));
    }
}


输出结果
Integer Array: [35, 22, 20, 15, 10]

数组可以排序，集合也可以排序：可以通过工具类java.util.Collections中的sort方法进行排序

static <T> void sort(List<T> list, Comparator<? super T> c)

完整示例：

import java.util.*;

public class ListSortTest {
  public static void main (String[] args) {
    List<Student> ar = new ArrayList<Student>();
    ar.add(new Student(111, "bbbb", "london"));
    ar.add(new Student(131, "aaaa", "nyc"));
    ar.add(new Student(121, "cccc", "jaipur"));

    System.out.println("原始集合");
    for (int i=0; i<ar.size(); i++) {
      System.out.println(ar.get(i));
    }

    // 实现升序排序
    Collections.sort(ar, new Comparator<Student>(){
      public int compare(Student a, Student b) {
        // 第一个参数的学号 > 第二个参数的学号
        return a.getRollNo() - b.getRollNo();
      }
    });

    System.out.println("\n排序后的集合");
    for (int i=0; i<ar.size(); i++) {
      System.out.println(ar.get(i));
    }

  }
}

删除remove：移除集合中的某个元素

List.remove(int index)

合并 addAll：将两个集合合并为一个集合

list1.addAll(list2);              //将集合2合并到集合1中

截取 subList：截取集合中的某一段内容

 List<String> arrlist2 = list.subList(2, 4);  截取索引2到4的内容

退役熬夜冠军选手

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java基础部分

第一章创建对象1.1 java包管理器导入包的语句：import 包名+类名例如：在计算机磁盘内的路径java/time/LocalDate.javaimport java.time.LocalDate;我们来看一下 LocalDate这个日期类：日期时间和字符串的转化：import java.time.LocalDate; //日期类import java.time.format.DateTimeFormatter; //日期格式化类pu
复制链接

扫一扫