常用类库

最新推荐文章于 2024-05-31 10:25:43 发布

大胖驾到

最新推荐文章于 2024-05-31 10:25:43 发布

阅读量87

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_51239196/article/details/120622005

版权

泛型

泛型使用类

泛型，即“参数化类型”。就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定
义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

 Person<String> p = new Person<>();
        p.setDate("123");
        System.out.println(p.getDate());


public class Person<T> {
    private String name;
    private int age;
    private T date;

泛型接口

public interface IntercaceName<T>{
T getData();
}
实现接口时，可以选择指定泛型类型，也可以选择不指定，如下：
指定类型：
public class Interface1 implements IntercaceName<String> {
private String text;
   @Override
   public String getData() {
     return text;
   }
}
不指定类型：
public class Interface1<T> implements IntercaceName<T> {
private T data;
   @Override
   public T getData() {
     return data;
   }
}

泛型方法

private static <T> T 方法名(T a, T b) {}

泛型限制类型

1. 在使用泛型时，可以指定泛型的限定区域，
- 例如：必须是某某类的子类或某某接口的实现类，格式：
<T extends 类或接口1 & 接口2>

泛型中的通配符？

类型通配符是使用？代替方法具体的类型实参。
1 <? extends Parent> 指定了泛型类型的上届
2 <? super Child> 指定了泛型类型的下届
3 <?> 指定了没有限制的泛型类型

package com.kkb;

public class Demo {
    public static void main(String[] args) {
        Plater<? extends Fruit> p = new Plater<Apple>();
        Plater<? super Apple> n = new Plater<Fruit>();
    }
    interface Fruit{};
    class Apple implements Fruit{};
    static class Plater<T>{
        T date;
    }
}

作用

1、提高代码复用率
2、泛型中的类型在使用时指定，不需要强制类型转换（类型安全，编译器会检查类型）

注意

在编译之后程序会采取去泛型化的措施。
也就是说Java中的泛型，只在编译阶段有效。
在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出，并且在对象进入和离开方法的边界处添加
类型检查和类型转换的方法。也就是说，泛型信息不会进入到运行时阶段。

Objects

此类包含static实用程序方法，用于操作对象或在操作前检查某些条件。这些实用程序包括null或null方法，用于计算对象的哈希代码，返回对象的字符串，比较两个对象，以及检查索引或子范围值是否超出范围。
变量和类型方法描述
static int checkFromIndexSize(int fromIndex, int size, int length) 检查是否在子范围从 fromIndex （包括）到 fromIndex + size （不包括）是范围界限内 0 （包括）到 length （不包括）。
static int checkFromToIndex(int fromIndex, int toIndex, int length) 检查是否在子范围从 fromIndex （包括）到 toIndex （不包括）是范围界限内 0 （包括）到 length （不包括）。
static int checkIndex(int index, int length) 检查 index是否在 0 （含）到 length （不包括）范围内。
static <T> int compare(T a, T b, Comparator<? super T> c) 如果参数相同则返回0，否则返回 c.compare(a, b) 。
static boolean deepEquals(Object a, Object b) 返回 true如果参数是深层相等，彼此 false其他。
static boolean equals(Object a, Object b) 返回 true如果参数相等，彼此 false其他。
static int hash(Object... values) 为一系列输入值生成哈希码。
static int hashCode(Object o) 返回非的哈希码 null参数，0为 null的论点。
static boolean isNull(Object obj) 返回 true如果提供的参考是 null ，否则返回 false 。
static boolean nonNull(Object obj) 返回 true如果提供的参考是非 null否则返回 false 。
static <T> T requireNonNull(T obj) 检查指定的对象引用是否不是 null 。
static <T> T requireNonNull(T obj, String message) 检查指定的对象引用是否为null ，如果是，则抛出自定义的NullPointerException 。
static <T> T requireNonNull(T obj, Supplier<String> messageSupplier) 检查指定的对象引用是否为null ，如果是，则抛出自定义的NullPointerException 。
static <T> T requireNonNullElse(T obj, T defaultObj) 如果它是非 null ，则返回第一个参数，否则返回非 null第二个参数。
static <T> T requireNonNullElseGet(T obj, Supplier<? extends T> supplier) 如果它是非 null ，则返回第一个参数，否则返回非 null值 supplier.get() 。
static String toString(Object o) 返回调用的结果 toString对于非 null参数， "null"为 null的说法。
static String toString(Object o, String nullDefault) 如果第一个参数不是 null ，则返回在第一个参数上调用 toString的结果，否则返回第二个参数。

Math

类Math包含用于执行基本数字运算的方法，例如基本指数，对数，平方根和三角函数。

//求绝对值
        System.out.println(Math.abs(-200));
        //求最大最小值
        System.out.println(Math.min(1000,2000));
        System.out.println(Math.max(1000,2000));
        //四舍五入
        System.out.println(Math.round(100.55));
        System.out.println(Math.round(-100.5));
        //返回小于等于参数的最大整数
        System.out.println(Math.floor(3.5));
        System.out.println(Math.floor(-3.5));
        //返回大于等于参数的最大整数
        System.out.println(Math.ceil(3.5));
        System.out.println(Math.ceil(-3.5));

Arrays数组

该类包含用于操作数组的各种方法（例如排序和搜索）。此类还包含一个静态工厂，允许将数组视为列表。
如果指定的数组引用为null，则此类中的方法都抛出NullPointerException ，除非另有说明。

包含在此类的方法中的文件包括的实施方式的简要描述。这些描述应被视为实施说明 ，而不是规范的一部分 。只要遵守规范本身，实现者就可以随意替换其他算法。（例如， sort(Object[])使用的算法不一定是sort(Object[]) ，但它必须是稳定的 。）

int[] arr = {8, 64, 12, 4, 63, 1};
        //System.out.println(arr);
        //遍历数组
        System.out.println(Arrays.toString(arr));
        //排序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        //查找下标
        System.out.println(Arrays.binarySearch(arr,12));
        //动态扩容,把数组扩容到20
        arr = Arrays.copyOf(arr,20);
        System.out.println(arr.length);

Bigdecoma

不可变的，任意精度的带符号十进制数。 A BigDecimal由任意精度整数非标度值和32位整数标度组成 。如果为零或正数，则比例是小数点右侧的位数。如果是负数，则将数字的未缩放值乘以10来表示比例的否定。因此， (unscaledValue × 10-scale)代表的BigDecimal值为(unscaledValue × 10-scale) 。

常用构造方法

public BigDecimal(String val){

}

常用方法

package com.kkb;

import java.math.BigDecimal;


public class Demo {
    public static void main(String[] args) {
        BigDecimal b1 = new BigDecimal("0.6");
        BigDecimal b2 = new BigDecimal("0.3");
        //加
        BigDecimal b3 = b1.add(b2);
        //减
        BigDecimal b4 = b1.subtract(b2);
        //乘
        BigDecimal b5 = b1.multiply(b2);
        //除法
        BigDecimal b6 = b1.divide(b2);
        b3.doubleValue();
        System.out.println(b3);
        System.out.println(b4);
        System.out.println(b5);
        System.out.println(b6);
    }
}

DateFormat

确定时间日期

package com.kkb;

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


public class Demo {
    public static void main(String[] args) throws ParseException {
        //DateFormat
        /**
         * y  :    年
         * M  :    月
         * d  :    日
         * m  :    分
         * s  :    秒
         *
         * 2021年10月09日     12:12   50
         */
        SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日 HH:mm ss");
        String text = format.format(new Date());
        System.out.println(text);
        SimpleDateFormat format1 = new SimpleDateFormat("yyyy-MM-dd HH:mm ss");
        String ieda = format1.format(new Date());
        System.out.println(ieda);
        //parse: 将yyyy-MM-dd HH:mm ss 日期字符串转换为date对象
        Date date = format.parse("2020-10-09 20:40 41");
        System.out.println((new Date().getTime()-date.getTime()/1000/60/60/24);
    }
}

Calend 日历

Calendar c1 = Calendar.getInstance();
        //设置年份
        c1.set(Calendar.YEAR,2022);
        //获取年份
        int year = c1.get(Calendar.YEAR);
        //是今年的第几天
        int day = c1.get(Calendar.DAY_OF_YEAR);
        //获取今年的第几周
        int week = c1.get(Calendar.WEEK_OF_YEAR);
        System.out.println(week);
        System.out.println(year);
        System.out.println(day);

// set设置
    // get得到
    // add增加
    //getTime :  获取日历时间  表示Date对象
    //getActuakMaxnum : 获取某字段的最大值
    public static void main(String[] args) {
       Calendar c1 = Calendar.getInstance();
       //0-11  2021-10-9
        //c1.add(Calendar.MONTH,3);
        //System.out.println(c1.get(Calendar.MONTH));
        //获取修改后的时间
        //Date d = c1.getTime();
        c1.set(Calendar.YEAR,1);
        int m = c1.getActualMaximum(Calendar.DAY_OF_YEAR);
        System.out.println(m);

String

package com.kkb;



public class Demo {
    public static void main(String[] args) {
        //线程不安全的实现
      StringBuilder sb = new StringBuilder();
      sb.append("12");
      sb.append("sh");
      sb.append("56");
      String text = sb.toString();
      System.out.println(sb);
      //线程安全
        StringBuffer xn = new StringBuffer();
        xn.append("46");
        xn.append("sj");
        xn.append("123");
        String na = xn.toString();
        System.out.println(na);
    }
}

package com.kkb.task10301001;

import com.kkb.task10301001.pojo.Student;

public class StringFunctionTest {
    /**
     * 编写一个方法，将一段文本中的各个单词的字母顺序翻转，
     * 例如："I like writing code best"，将变成"I ekil gnitirw edoc tseb"。
     * @param str
     * @return
     */
    public String myReversr(String str){
        //1. 将字符串按照空格分隔为数组  字符串中split
        String[] arr = str.split(" ");
        //2. 遍历字符串,将每个单词反转  StringBuffer 中的 revers方法
        StringBuffer newStr = new StringBuffer();//新的字符串
        for (String s : arr) {
            StringBuffer stringBuffer = new StringBuffer(s);//将字符串转换为StringBuffer
            stringBuffer.reverse();//调用StringBuffer中revers方法进行字符串的翻转
            newStr.append(stringBuffer).append(" ");//将翻转完毕的字符串拼接到新的字符串之中
        }
        return newStr.toString();
    }

    /**
     *  String s="name=王五 age=18 classNum=1101”;
     * 将上面的字符串中包含的信息存放到 Student（里面有 name，age，
     * classNum 三个属性）的对象中:
     */
    public void test2(){
        Student stu = new Student();
        String s = "name=王五 age=18 classNum=1101";
        String[] arr = s.split(" ");
        for (String s1 : arr) {
            String[] temp =s1.split("=");
            if (temp[0].equals("name"))
                stu.setName(temp[1]);
            else if (temp[0].equals("age"))
                stu.setAge(Integer.valueOf(temp[1]));
            else if (temp[0].equals("classNum"))
                stu.setClassNum(Integer.valueOf(temp[1]));
        }
        System.out.println("学生信息:"+stu);
    }

    /**
     * 字符串压缩:利用字符重复出现的次数，编写一种方法，实现基本的字符
     * 串压缩功能。比如,字符串“aabccdd”会变成“a2b1c2d2”。若“压缩”以后的字
     * 符串没有变短，则返回原先的字符串。你可以假设字符串中只包含大小写英文
     * 字母(a-z)
     * @param s
     * @return
     */
    public String compress(String s){
        //考虑极端情况，空字符串处理
        if (s.length()==0){
            return s;
        }
        StringBuffer newStr = new StringBuffer();
        char ch = s.charAt(0);//表示当前要压缩的字符
        int js = 1;//表示当前要压缩字符的个数
        for (int i =1;i<s.length();i++){
            if (ch==s.charAt(i)){//表示当前的字符与压缩的字符相同
                js++;
            }else {
                newStr.append(ch);
                newStr.append(js);
                ch=s.charAt(i);
                js=1;
            }
        }
        newStr.append(ch);
        newStr.append(js);
        return newStr.length()>s.length()?s:newStr.toString();//最后比对大小返回更短的字符串
    }

    /**
     * 写一个和 trim 功能相同的方法
     * 1.定义两个变量，用来存储两个角标
     * 2.分别从头和尾遍历字符串，直到找到第一个不为空格的字符
     * 3.截取字符串
     * @param s
     * @return
     */
    public String myTrim(String s){
        //1.定义两个变量，用来存储两个角标
        int index1=0;
        int index2=s.length()-1;
        //2.分别从头和尾遍历字符串，直到找到第一个不为空格的字符
        for (int i =0;i<s.length();i++){
            if (s.charAt(i)!=' '){
                index1 = i;
                break;
            }
        }
        for (int i=s.length()-1;i<=0;i--){
            if (s.charAt(i)!=' '){
                index2=i;
                break;
            }
        }
        //3. 截取字符串
        return s.substring(index1,index2);
    }

    public static void main(String[] args) {
        StringFunctionTest test = new StringFunctionTest();
        //测试一段文本中的各个单词的字母顺序翻转
        //String s = test.myReversr("I like writing code best");
        //System.out.println(s);
        //测试题2
        //test.test2();
        //测试题3
        //String s = test.compress("aabcccccddddd");
        //System.out.println(s);
        //测试题四
        String s = test.myTrim(" aabcc ccc ddddd ");
        System.out.println("调用结果:"+s);
    }
}

package com.kkb.task10301001.pojo;
//第二题
public class Student {
    private String name;
    private Integer age;
    private Integer classNum;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", classNum=" + classNum +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

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

    public Integer getClassNum() {
        return classNum;
    }

    public void setClassNum(Integer classNum) {
        this.classNum = classNum;
    }
}

大胖驾到

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
常用类库

泛型泛型，即“参数化类型”。就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。 Person<String> p = new Person<>(); p.setDate("123"); System.out.println(p.getDate());public class Person<T> { private
复制链接

扫一扫