java如何包装简历 java开发怎么包装经验

目录

• 包装类的分类
• 包装类和基本数据类型的转换
• Integer类和Character类的常用方法

• Integer.MIN_VALUE（返回最大值）
• Integer.MAX_VALUE（返回最小值）
• Character.isDigit('a')(判断是不是数字）
• Character.isLitter('a')(判断是不是字母）
• Character.isUpperCase（'a'）（判断是不是大写）
• Character.isLowerCase('a')（判断是不是小写）
• Character.isWhitespace('a')(判断是不是空格)
• Character.toUpperCase('a')（转换成大写）
• Character.ToLowerCase('A')(转换成小写)

• 要注意的习题

• String类

• String的内存分布关系图：

• 两种创建String对象的区别

• 字符串的特性
• String类的常见方法：
• StringBuffer类

• String VS StringBuffer
• StringBuffer构造器的使用

• String和StringBuffer的相互转化

• 1、String--->StringBuffer
• 2、StringBuffer --->String

• StringBuffer的常用方法

• 增
• 删
• 改
• 查
• 插
• 长度

• StringBuilder类

• 基本介绍

• StringBuilder类解读
• String StringBuffer 和StringBuilder的选择
• String、StringBuffer和StringBuilder的比较

• Math类

• Math常见方法：

• Arrays类

• 常见方法：

• 1、toString（arr）返回数组的字符串形式【Arrays.toString( )】
• 2、sort排序（自然排序和定制排序）【Arrays.sort(arr)】
• 3、binarySearch 通过二分搜索法进行查找，要求必须是有序数组【Arrays.binatySearch（arr，3）】
• 4、copyOf 数组元素的复制【Integer [ ] newArr = Arrays.CopyOf(arr,arr.length)】
• 5、fill 数组元素的填充
• 6、equals 比较两个数组元素内容是否完全一致
• 7、asList将一组值转换成list【Arrays.asList(3,4,52,1)】

• System类

• 常见方法

• 大数处理

• Biglenteger和BigDecime

• 常见方法：

• 日期类

• 第一代日期类
• 第二代日期类
• 第三代日期类

• 前面两代类的不足分析
• 第三代

• String 相关习题

• String翻转

包装类的分类

1、针对八种基本数据类型的引用类型

2、有了类的特点，就可以调用类中的方法

包装类和基本数据类型的转换

1、JDK5以前的手动装箱和拆箱方式。装箱：基本类型—>包装类型。反之是拆箱
2、JDK5以后的自动装箱和拆箱方式
3、其他的类型和int类型相似

public class Main {

    public static void main(String[] args) {
	// write your code here
        //int转Integer
        int n1 = 100;
        //方法1(手动装箱)
        Integer integer = new Integer(n1);
        Integer integer2 = Integer.valueOf(n1);
        //手动拆箱
        int n2 = integer2.intValue();

        //在jdk5以后 自己装拆箱
        //自动装箱
        Integer i = n1;//Integer.valueOf(n1)
        //自动拆箱
        int n3 = i;//integer2.intValue();
}

Integer类和Character类的常用方法

Integer.MIN_VALUE（返回最大值）

Integer.MAX_VALUE（返回最小值）

Character.isDigit(‘a’)(判断是不是数字）

Character.isLitter(‘a’)(判断是不是字母）

Character.isUpperCase（‘a’）（判断是不是大写）

Character.isLowerCase(‘a’)（判断是不是小写）

Character.isWhitespace(‘a’)(判断是不是空格)

Character.toUpperCase(‘a’)（转换成大写）

Character.ToLowerCase(‘A’)(转换成小写)

要注意的习题

String类

1、String对象用于保存字符串，
2、字符串常量对象时用双引号括起来的字符序列
3、字符串的字符使用的是Unicode字符编码，一个字符（不分汉字还是字母）都占两个字节
4、String类较常用的的构造器

String s1 = new Strig ();
String s1 = new Strig (String original);
String s1 = new Strig (char[] a);
String s1 = new Strig (char [] a,int startindex);
5、String类实现了Serilizable接口，【String 可以串行化：可以再网络中传输】
Comparable【String 对象可以进行大小比较】

6、String类是final类，不能被其他类继承，
7、String 有属性 private final char value [ ]:用于存放字符串内容
8、一定要注意：value是一个final类型，不可以修改：即不能指向其他新的地址，但是里面的字符内容是可以改变的

String的内存分布关系图：

两种创建String对象的区别

方式一：直接赋值：String s = “HYP”;

方式二：调用构造器 String s = new String(“HYP”);

1、方式一：先从常量池中查看是否有“HYP“数据空间，如果有，直接指向；如果没有则重新创建，然后指向。s最终指向的是常量池的空间地址

2、方式二：现在堆中创建空间，里面有value属性，value指向常量池的的hyp空间。如果常量池没有HYP，就去创建，如果有，直接通过value直向。最终指向的是堆中的空间地址

字符串的特性

String a = “hello”;
String b = “abc”;
String c = a + b;
分析上面的代码创建了几个对象，

底层是：StringBuilder sb = new StringBuilder(); sb.append(a); sb.append(b); sb是在堆中，并且append是在原来的字符串的基础上追加的

**重要规则:**string c = “ab”+“cd”; 常量相加，看的是池。String c1 = a + b;变量相加，是在堆中

String类的常见方法：

equals // 判断内容是否相同 区分大小写
equalsIgnoreCase//忽略大小判断内容是否相同
length //获取字符个数，字符串的长度
indexOf //获取字符在字符串中第一次出现的索引，索引从零开始（找不到返回-1）
lastIndexOf//获取字符在字符串中最后1次出现的索引，索引从零开始，找不到返回-1
substring( a,b)//截取指定范围的字串
charAt（）//获取某索引出的字符，

toUpperCase（将字符串中所有字符转换成大写）
tolowerCase//将字符串中所有字符转换成小写
concat//拼接字符串
erplace //将字符串中的指定字符串替换成指定字符串
split//分割字符串（数组接收）
comperTo //比较两个字符串的大小
toCharArray //将字符串转换成字符数组
format//格式字符串，%s 字符串 %c 字符 %d 整形 %.2f 浮点型

public class B {
    public static void main(String[] args) {
        //1、equals 方法 比较内容是否相同 区分大小写
        String str1 = "hello";
        String str2 = "Hello";
        System.out.println(str1.equals(str2));//F

        //2、equalsIgnoreCase  忽略大小写的判断内容是否相同
        String username = "HHH";
        String name = "hhh";
        System.out.println(username.equalsIgnoreCase(name));//T

        //3、length() 获取字符串字符的个数，字符串的长度
        System.out.println("qwer".length());

        //4\indexOf 获取字符在字符串对象中第一次出现的索引，索引从零开始。如果找不到返回-1；
        String s1 = "werterweg";
        System.out.println(s1.indexOf('#'));//-1
        System.out.println(s1.indexOf('r'));//2
        //5、lastIndexOf  获取字符在字符串对象中最后一次出现的索引。从零开始
        String s2 = "qweef";
        System.out.println(s2.lastIndexOf('e'));//3
        System.out.println(s2.lastIndexOf("we"));//1
        //6、substring 截取指定范围的字符串
        String ss = "hello.张三";
        //ss.substring(6),从索引6开始截取后面的字符串（包含6）
        System.out.println(ss.substring(6));
        //ss.substring(a,b),表示从索引a开始截取（包含a），截取到索引b-a的位置（不包含b-a）
        //就是截取[a,b)集合范围内的字符串
        System.out.println(ss.substring(1,3));//el

        //toUpperCase()将字符串中的字符全部转换为大写
        String a = "Hello";
        System.out.println(a.toUpperCase());//HELLO
        //toLowerCase()将字符串中的字母全部转换为小写
        String b = "UIUI";
        System.out.println(b.toLowerCase());//uiui
        //concat（）拼接字符串
        String c = "你好";
        c = c.concat("李焕英").concat("的朋友");
        System.out.println(c);
        //replace（）将字符串中的字符或字符串替换为指定字符（字符串）
        String d = "宝玉 and 林黛玉 林黛玉 林黛玉";
        d= d.replace("林黛玉","宝玉");
        d = d.replace('a','h');
        System.out.println(d);//宝玉 hnd 宝玉 宝玉 宝玉
        /**
         * 注意：
         * d.replace()执行后的返回结果才是替换过的，对原本字符串没有任何影响
         */
        //split  分割字符串。，对于某些字符我们需要转义
        String f = "锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦";
        String []ff = f.split(",");
        for (int i = 0; i < ff.length; i++) {
            System.out.println(ff[i]);
        }
        f = "E\\aaa\\bbb";
        ff = f.split("\\\\");
        for (int i = 0; i < ff.length; i++) {
            System.out.println(ff[i]);
        }
        //toCharArray() 转换成字符数组
        f = "happy";
        char []cc = f.toCharArray();
        for(char i : cc){//增强for
            System.out.println(i);
        }
        //compareTo 比较两个字符串的大小，
        // 如果前者大 返回正数 后者大 返回负数 相等返回0‘
        //Ctrl + B 看源码；
        String q = "jac";//len = 3；
        String w = "jack";//len = 4
        System.out.println(q.compareTo(w));//-1;
    }

}

StringBuffer类

String VS StringBuffer

1. String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址，效率较低（字符串在：堆中的private final char value [ ] 指向常量池）
2. StringBuffer保存的是字符串变量里面的值可以更改，每次StringBuffer的更新实际上可以更新内容不用更改地址效率较高( 这个字符串是在堆中的 char [ ] value）
3. StringBuffer的直接父类是 AbstractStringBuilder
4. StringBuffer实现了 serializable 接口 即StringBuffer的对象可以串行化（对象可以网络传输，可以保存到文件）
5. 在父类 AbstractStringBuilder 中 有属性 char [ ] value ，不是final。该value数组存放字符串内容是存放在堆中的
6. StringBuffer 是一个final类 不能被继承
7. 因为 StringBuffer 字符串内容是在 char [ ] value ，所有在变化(增加或删除)不用每次都更换地址（即不是每次都创建新对象）所以效率高于String

StringBuffer构造器的使用

new StringBuffer()//构造器
1、创建一个大小为 16 的 char [ ] 用于存放字符内容
2、通过构造器指定 char [ ] 的大小
new StringBuffer（100）
通过给一个String str 创建 StringBuffer 这时char [ ] 大小就是 str.lengeh()
String str = “hello”;
StringBuffer hello = new StringBuffert(str);

String和StringBuffer的相互转化

1、String—>StringBuffer

String str = "L"
//方式一 使用构造器转换
//注意：返回的才是StringBuffer 对象，对str本身没有影响
StrngBuffer StringBuffer = new StringBuffer (str);
//方式二 使用的是 append方法 
StringBUffer stringBuffer1 = new StringBuffer();
stringBuffer1 = stringBuffer1.append(str);

2、StringBuffer —>String

StringBuffer stringBuffer3 = new StringBuffer ("你好");
//方式一  使用StringBuffer提供的 toString方法
Stirng s = StringBuffer3.toString();
//方式二 使用构造器来搞定
String s1 = new String(stringBuffer3);

StringBuffer的常用方法

增

StringBuffer s = new StringBuffer(“hello”);
s.append(‘,’);
s.append(“张三丰”)；
s.append(“赵敏”).append(100).append(“true”).append(10.5);
代码结果是：“hello ，张三丰赵敏100true10.5”

删

删除 索引为：[ start , end) 区间的字符串
s.delete(11,14)//删除索引从十一开始（包含十一） 到 十四的字符串（不包含十四）

改

使用 “周芷若”替换 索引9–11的字符[9 , 11)
s.replace(9,11);
结果是：“hello,张三丰周芷若true10.5”

查

查找指定的字符串在字符串中第一次出现的索引，如果找不到就返回-1
int indexOf = indexOf（“张三丰”）；//6

插

hello,张三丰周芷若true10.5
s.insert(9,“赵敏”)；//hello,张三丰赵敏周芷若true10.5

在索引为9的地方插入“赵敏”，原来索引为9的地方变成“赵敏”之前的字符串内容自动向后移

长度

s.length();

StringBuilder类

基本介绍

1、一个可变的字符序列。此类提供一个与StringBuffer兼容的 API，但不保证同步（StringBuilder不是线程安全）。该类被设计用作StringBuffer的简易替换 用在字符串缓冲区被单个线程使用的时候，如果可能，简易优先采用该类，因为在大多数现实中，他比StringBuffer要快
2、在StringBuilder上的主要操作是append方法 和 insert方法，可重载这些方法，以接受任意类型的数据

StringBuilder类解读

1、StringBuilder继承了 AbstractStringBuilder类
2、实现了 serializable 说明StringBuilder的对象是可以串行化的
3、StringBuilder是final类 不可以被继承
4、StringBuilder对象的字符序列仍然是放在其父类AbstractStringBuilder的char [ ] value因此序列是在堆中的
5、StringBuilder的方法没有做互斥的助理 ，既没有synchronized关键字，因此在单线程的情况下使用StringBuilder

String StringBuffer 和StringBuilder的选择

使用原则：

1、如果字符串存在大量的修改操作，一般使用StringBuilder或者StringBuffer
2、如果字符串存在大量修改的操作，并在单线程的情况下蛮实用StringBuilder
3、 如果字符串存在大量修改的操作，并在多线程的情况下蛮实用StringBuffer
4、如果我们字符串很少修改被多个对象引用，使用String，比如配置信息等
StringBuilder的方法和StringBuffer一样**

String、StringBuffer和StringBuilder的比较

1. StringBuffer和StringBuilder非常类似，均代表可变的字符序列，而且方法也一样，
2. String：不可变字符序列。效率低，但是复用性高
3. StringBuffer：可变字符序列，效率较高（增删），线程安全
4. StringBuilder：可变字符序列、效率最高，线程不安全
5. String使用注意说明： String s = “a”//创建一个字符串
   s+=“b”；//实际上原来的“a”字符串已经丢弃了，现在有产生了一个字符串S+=“b”（也就是"ab"）如果多次执行这
   些改变字符串内容的操作，会导致大量的副本字符串对象存留在内存中降低效率。如果这样的操作放在循环中
   ，会极大的影响程序的性能===>>结论：如果我们对String做大量修改不要使用String

效率：StringBuilder>StringhBuffer>String

Math类

Math常见方法：

1. abs : 绝对值
2. pow：求幂
3. ceil：向上取整
4. floor：向下取整
5. round：四舍五入
6. sqrt：求开方
7. random：求随机数（获取a-b之间的随机整数【int num = （int）（Math.random()*(b-a+1)）】）
8. max：求两个数中的最大数
9. min：求两个数中的最小数

Arrays类

常见方法：

1、toString（arr）返回数组的字符串形式【Arrays.toString( )】

2、sort排序（自然排序和定制排序）【Arrays.sort(arr)】

import java.util.Arrays;
import java.util.Comparator;

public class ArraysMethod {
    public static void main(String[] args) {
        Book[] book = new Book[4];
        book[0] = new Book("红楼梦", 100);
        book[1] = new Book("西游记", 90);
        book[2] = new Book("青年文摘", 5);
        book[3] = new Book("java丛入门到放弃", 300);
        int[] arr = {1, 3, 5, -56, 45};
        Arrays.sort(arr);
        /**
         * 定制排序
         * 接口的匿名内部类返回的值是灵魂
         * return 的值决定了排序怎样进行
         */
        Arrayss.sort(book, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {

                double i1 = (double) o1;
                double i2 = (double) o2;
                return  (int)(i1 - i2);//这里决定了排怎么（从大到小还是……）
            }
        });
        System.out.println("=====排序后的数=====");
        for (int i = 0; i < book.length; i++) {
            System.out.println(book[i]);
        }


    }

    static class Arrayss {
        public static void sort(Book[] arr, Comparator comp) {
            Book temp = null;
            for (int i = 0; i < arr.length; i++) {
                for (int j = 0; j < arr.length - i - 1; j++) {
                    //按照书的价钱排
                    if (comp.compare(arr[j].getPrice(), arr[j + 1].getPrice()) > 0) {//这里将数组中的值
                        // 传递给上面的匿名内部类中，返回值来确排序怎样进行
                        temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }

            }
        }
    }

}

class Book {
    private String name;
    private double price;

    public Book(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

3、binarySearch 通过二分搜索法进行查找，要求必须是有序数组【Arrays.binatySearch（arr，3）】

如果数组时无序的不能使用此方法查找
	     数组中不存在此元素，就return -（low+1）【要找的数据在有序元素中按大小可以存在的位置的相反数】

4、copyOf 数组元素的复制【Integer [ ] newArr = Arrays.CopyOf(arr,arr.length)】

从arr数组中拷贝arr.length个元素到newArr数组中

5、fill 数组元素的填充

【Intrger [ ]num = new Integer [ ] {3,4,5};
	    Arrays.fill(num,99)】

6、equals 比较两个数组元素内容是否完全一致

【Boolean equals = Arrays.equals(arr1,arr2)】

7、asList将一组值转换成list【Arrays.asList(3,4,52,1)】

System类

常见方法

1、exit（）； 退出当前程序
2、arraycopy ；复制数组元素，比较适合底层使用，一般使用 Arrays.copyOf完成数组的赋值

System.arraycopy(arr1,a,arr2,b,length)
arr1:原数组
a: 从原数组的那个索引位置开始拷贝
arr2：目标数组
b:把原数组的元素拷贝到目标数组的那个索引
length：从原数组拷贝几个元素

3、currentTimeMillens：返回当前时间距离1970年1月1日的毫秒数
4、Syste.gc();垃圾处理机制

大数处理

Biglenteger和BigDecime

BigInteger：适合比较大的整形 【BigInteger i = new BigInteger(“44344543554354534345543554353543”);】
BigDecime：适合精确度比较大的浮点型（小数）【BigDecime j = new BigDecime(0.99999999999999999999999);】
加减乘除运算方式都一样
注意:在调用divide方法时可能需要指定精确度（BigDecime.ROUND_CEILING）【如果有无限循环小数就会保留分子的精度】

常见方法：

1、add：加
2、subtract ：减
3、multiply：乘
4、divide：除

BigInteger i = new BigInteger("44344543554354534345543554353543");
BigInteger j = new BigInteger("4");
//加   加减乘除调用方式一模一样
BigInteger add = i.add(j);

日期类

第一代日期类

1、Date ：精确到毫秒，代表特定的瞬间

获取当前系统时间
默认输出格式是按照国外的格式，所以要使用下面的类进行格式转换
new Date (799799) 这是获取799799毫秒的时间（从1970年1月1日算起）
d1.getTime（）获取d1时间的毫秒数

2、SimpleDateFormat（）格式化日期的类

Date d = new Date();//创建日期对象
//格式化日期（这里的格式转换字母是规定好的 不能乱写）
SimpleDateFormat  stf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss E");
//将日期转换成字符串
String format = sdf.format(d);

//将字符串转换成日期
String s = "2022年7月8日 14：20:30 星期五";
//这里使用的sdf的格式要和前面指定的SimpleDateFormat类的格式相同
//不然就会报错
Date date = sdf.parse(s);

第二代日期类

1、第二代日期类主要就是Calendar类（日历）
2、Calendar类是一个抽象类它为特定瞬间，与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法

import java.util.Calendar;
public class Calendar_{
    public static void main(String[] args) {
        /*
          Calendar是一个抽象类，并且构造器是private的
          可以通过getInstance来获取实例
          提供大量方法和字段给程序员
          Calendar没有提供对应格式化的类。需要程序员自己来组合
         */
        Calendar c = Calendar.getInstance();
        System.out.println("c="+c);
        System.out.println("年="+c.get(Calendar.YEAR));
        //这里加一是因为月份是从零开始返回的
        System.out.println("月="+(c.get(Calendar.MONTH)+1));
        System.out.println("日"+c.get(Calendar.DAY_OF_MONTH));
        System.out.println("小时"+c.get(Calendar.HOUR));
        System.out.println("分钟"+c.get(Calendar.MINUTE));
        System.out.println("秒"+c.get(Calendar.SECOND));

    }

}

第三代日期类

前面两代类的不足分析

1、可变性：像日期和时间这样的类应该是不变的
2、偏移性：Date中的年份是从1970年开始的，而月份都是从0开始的
3、格式化：格式化只对Date有用，Calendar则不行
4、此外，他们不是线程安全的，不能处理润秒等（每隔两天就会多出一秒）

第三代

1、使用now（）返回表示当前时间日期的对象

LocalDateTime ldt = LocalDateTime.now();
ldt.getYear();
ldt.getMounth();//英文显示的月份
ldt.getMounthValue();//数字显示的月份
ldt.getDayOfMounth();//日
ldt.getHour();//时
ldt.getMinut();//分
ldt.getSecond();//秒

2、使用DateTimeFormatter 对象进行格式化

DateTimeFormatter dateTimeFormatter =  DateTimeFormatter.ofpattern("yyyy-MM-dd hh:mm:ss");
String format = dateTimeFormatter.format(ldt);

3、使用 LocalDate.now()可以获取到年月日
4、使用 LocalTime.now()获取到时分秒
5、提供plus和minus方法可以吧当前时间进行加或者减

//当前时间的100天后的时间
LocalDateTime localDateTime = ldt.plusDays(100);
//当前时间的100分钟以前的时间
LocalDateTime localDateTime2 = ldt.minusMinutes(100);

使用 静态方法 now（）’获取当前时间戳的对象
Instance now = Instance.now();
通过from可以将Instance转换成Date
Date date = Date.from(now);
通过Date的toInstance方法可以吧Date转换成Instance对象
Instance instance = date.toInstance();

String 相关习题

String翻转

class StringFlip {
    public static void main(String[] args) {
        String s = "wsdfkr";
        s = StringFlip.flip(s, 1, 5);
        System.out.println("s反转后=" + s);
    }

    private static String flip(String str, int start, int end) {
        char[] chars = str.toCharArray();//将传入的字符串转换成数组
        char temp = ' ';
        //将最后一个第一个对调
        // 第二个和倒数第二个对调
        //……
        //直到中间的那个，从头往后的标记不能去从后往前的标记后面
        for (int i = start, j = end; i < j; i++, j--) {
            temp = chars[i];
            chars[i] = chars[j];
            chars[j] = temp;
        }
        return new String(chars);//返回一个新的字符串
    }
}