学习大数据所以需要的java基础（2）-CSDN博客

本文链接：https://blog.csdn.net/weixin_46668520/article/details/135659661

String介绍

String概述

1.概述
string类代表字符串类型
2.特点
a.java 程序中的所有字符串字面值（如“abc”）都作为此类的实例实现
凡是带双引号的，都是String的对象
String s = “abc”;
String:是数据类型，字符串类型
s 是对象名
“abc”是String类型的一个对象
b.字符串是常量，他们的值在创建之后不能更改
字符串底层是一个被final修饰的数组
比如 String s = “hello”
s += “world”
c.String对象是不可变的所以可以共享
比如 String s1 = “abc”
String s2 = “abc”
s1==s2 ，s1是等于s2的因为他们的地址一样

String的实现原理

1.string的实现原理：底层是一个数组
a.jdk9之前：string的底层是一个被final修饰的char数组-----一个char类型占2个字节
b.jdk9以及之后：string底层是一个被final修饰的byte数组--------一个byte类型占1个字节
2.string底层的数组：
privat final char value[] ------数组被final修饰，地址值直接锁死，不能改变。

String的创建

1.String()–>根据空参构造创建String对象
2.String(String s)—>根据字符串创建String对象
3.String(char[] chars)---->根据char数组创建String对象
4.String(bytes[] bytes)---->通过使用平台的默认字符芥末指定的byte数组，构建一个新的String平台：操作系统—>GBK
a.如果byte数组元素为正数，直接将正整数转成对应的字符
b.如果byte数组元素为负数，需要区分码表了，因为中文对应在字节才能是负数
c.中文编码表常用的有
GBK：一个中文占2个字节
UTF-8：一个中文占3个字节
d.注意
代码是在idea中写的，在idea中运行的，在idea运行的过程中，会自动给代码加上一个启动参数
-Dfile.encoding = UTF-8
5.简化
String 对象名 = “”

String拓展构造

Sting int(byte[] bytes, int offset, int length)-----将byte数组的一部分转换成string对象
bytes：要转换的数组
offset：从数组的哪个索引开始转
length：转多少个
String(char[] value, int offset , int count)-----将char数组的--------一部分转成Sting对象
value 要转的数组
offset 从数组的哪个索引开始转
count 转多少个
String(byte[] bytes, String CharsetName)--------------按照指定的编码表将byte数组转成string对象

面试题

public class test03 {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "abc";
        String s3 = new String("abc");
        System.out.println(s1 == s2);   //true
        System.out.println(s2 == s3);   //false
        System.out.println(s1 == s3);   //false

    }
}

String s1 = new String(“abc”);
在创建过程中共创建了几个对象？ ------ 一个或两个
1.如果abc在new的时候提前创建出来了，那么new的时候只产生了一个对象 – new的
2.如果abc在new的时候没有提前创建出来，那么就是先创建abc，再new，然后将abc作为String的有参构造参数
传递到string构造中 ------- 两个对象

判断方法

Boolean equals（object a）比较字符串内容是否相等
boolean qqualsIngnorCase(String s) 比较字符串内容，忽略大小写
static boolean equals(object a,object b) -----比较内容，但是防止空指针异常

String的Get方法

public int length(): 返回此字符串的长度
public String concar(String str) 将指定的字符串拼接到老串的末尾，产生一个新串，老串不动
char charAt(int index)：返回指定索引处的char值
int indexOf(String str)获取的是指定字符串再老串中第一次出现的索引位置
String substring(int beginIndex) 返回一个字符串，从begiIndex开始截取字符串到字符串末尾，老串不动
String substring(int beginIndex, int endIndex) 返回一个子字符串，从beginIndex到endIndex截取字符串，含begIndex，不含endIndex

String的转换方法

char[] toCharArraay() — 将字符串转换成char数组
byte[] getBytes() ----- 使用默认字符集，将子父串转成字节数组
String replace(CharSequence target, CharSequence replacement) — 将target匹配的字符串使用replaceme字符串替换

拓展
byte[] getBytes(String chaesetName) ------ 按照指定编码集将字符串转成byte数组

public class test07 {
    public static void main(String[] args) {
        String a = "sadfeace";
//        char[] toCharArraay()  --- 将字符串转换成char数组
        char[] chars = a.toCharArray();
        System.out.println(chars);
//        byte[] getBytes()  ----- 使用默认字符集，将子父串转成字节数组
        byte[] bytes = a.getBytes();
        ///转换为字符串
        System.out.println(Arrays.toString(bytes));
//        String replace(CharSequence target, CharSequence replacement) --- 将target匹配的字符串使用replaceme字符串替换
//
        System.out.println(a.replace('a','b'));
//        拓展
//        byte[] getBytes(String charsetName)  ------ 按照指定编码集将字符串转成byte数组
        byte[] bytes1 = "小鬼子".getBytes(StandardCharsets.UTF_8);
        System.out.println(Arrays.toString(bytes1));
        String s = new String(bytes1);
        System.out.println(s);
    }
}

分割功能

String[] split(String regex) ------ 按照指定的字符规划分割字符串，返回string类型

import java.util.Arrays;

public class test09 {
    public static void main(String[] args) {
        String s = "python,java";
        String[] s1 = s.split(",");
        System.out.println(Arrays.toString(s1));
        String[] s2 = s.split("\\,");
        System.out.println(Arrays.toString(s2));
    }
}

StringBulider

介绍

1.StringBuilder的作用：主要是用于字符串拼接
2.问题：StringBuilder有什么优势
a.Stiring拼接字符串，每拼接一次，都产生一个新的字符串对象，只要产生字符串对象，都会占用内存
b.StringBuilder自带缓冲区，拼接的字符串会直接放到缓冲区中不会产生新的字符串对象，始终就StringBuilder
一个缓冲区，节省内存
3.StringBuilder的特点
a.StringBuilder自带一个缓冲区，其实就是一个没有被final修饰的char数组
b.在拼接的过程中，只有一个缓冲区占用内存，不会产生新的对象
c.StringBuilder底层缓冲区（char数组）的长度为16
d.如果超出了缓冲区范围，StringBuilder会自动扩容
注意：数组扩容不是在原来的基础上扩容的
先创建一个扩容后的新数组，然后将老数组中的数据赋值到新数组中，然后将新数组的地址值重新赋值给老数组
扩容2倍加2

StringBuilder的使用

1.构造
StringBuilder()----创建完之后缓冲区中没有数据
StringBuilder(String s)--------创建完后缓冲区中有数据
2.常用方法
StringBuilder append（任意类型的数据） ------ 字符串拼接，返回的是StringBuilder自己
StringBuilder reverse() --------字符串翻转
String toString() ------- 将StringBuilder对转回String对象
因为我们使用StringBuilder就是为了拼接字符串，不过多占用内存，拼接效率高
拼接完之后，我们后续肯定要处理操作字符串，此时需要调用String中的方法，所以
拼接完之后，我们需要将StingBuilder编程String，调用String的方式操作拼接好的字符串

String和StringBuilder以及StringBuffer区别

1.StringBuffer从使用上，从特点上和StringBuilder一模一样
相同点
1.都可以用字符串拼接
不同点
1.String 每拼接一次都会产生一个新的字符串对象
2.StringBuilder：每拼接一次不会产生一个新的字符串对象，效率高，线程不安全
3.StringBuffer:每拼接一次不会产生一个新的字符串对象，效率低，线程安全
从拼接效率上来说
String < StringBuffer < StringBuilder

Stream流

stream介绍及示例

概念：相当于流水线一个流水线上有好多个操作，下一个操作都是在上一个操作的基础上进行再次加工处理
举个筛选的例子，正常我们写代码

package Stram_test;

import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class test01 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("独立团李云龙");
        list.add("独立团张大彪");
        list.add("孔捷");
        list.add("丁伟");
        list.add("独立团魏大勇");
        list.add("独立团段鹏");
        ArrayList<String> duli = new ArrayList<>();
        ArrayList<String> sanzi = new ArrayList<>();
        判断是不是独立团
        for (int i = 0; i < list.size(); i++) {
            String element = list.get(i);
            if (element.startsWith("独"))
                duli.add(element);
        }
        ///名字是不是三个字
        for (int i = 0; i < duli.size(); i++) {
            String element = duli.get(i);
            if ((element.length() == 6))
                sanzi.add(element);
        }
        System.out.println(duli);
        System.out.println(sanzi);

使用stream流

System.out.println("===========使用stream流===================");
        //list转换为Stream流对象
        Stream<String> stream = list.stream();
        /*stream.filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.startsWith("独");
            }
        }).filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length() == 6;
            }
        }).forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*/
        System.out.println("==========lambda表达式=================");
//        stream.filter(s ->s.startsWith("独")).filter((String s) -> s.length() == 6
//        ).forEach((String s) -> System.out.println(s));
        stream.filter(s -> s.startsWith("独")).filter(s -> s.length()==6).forEach(s -> System.out.println(s));
    }

Stream流的获取

steam流的获取主要分为针对数组：Sream流中静态方法
static Stream of (T…values)
Stream stream01 = Stream.of(“李云龙”,“孔捷”,“赵刚”)
针对于集合，单列集合
stream stream（）
ArrayList list = new ArrayList<>();
list.add(“丁伟”)；
list.add(“楚云飞”)；
list.add(“魏大勇”)；
list.add(“段鹏”)；
Stream stream02 = list.stream();

几个重要的类

Math类

概述：数学工具类
作用做数学运算
特点：
math中的构造方法是私有的
方法都是静态的
使用
类名直接调用

BigInteger类

BigInterger处理大正正数
我们可能遇到比long型的范围中的数还要大，比long型还大的整数，应该叫做对象
作用处理超大整数
构造
BigInteger(String val) ---- val要符合数字格式
使用：加减乘除
BigInteger add(BigInteger val)
BigInteger subtract(BigInteger val)
BigInteger multiply(BigInteger val)
BigInteger divide(BigInter val)

		BigInteger b1 = new BigInteger("12121212121212121212121212121212121212");
        BigInteger b2 = new BigInteger("12121212121212121212121212121212121212");
        BigInteger add = b1.add(b2);
        System.out.println(add);
        System.out.println(b1.subtract(b2));
        System.out.println(b1.divide(b2));
        System.out.println(b1.multiply(b2));

BigDecimal类

介绍
平常运算过程中，直接用double或者float类型的变量参与运算，很有可能会有精度损失问题
所以我们学的BigDecimal可以解决这个问题
作用
BigDecimal专门做小数运算（还能保证精度）
构造
BigDecimal(String val) ----- val;要符合数字格式

		BigInteger b1 = new BigInteger("12121212121212121212121212121212121212");
        BigInteger b2 = new BigInteger("12121212121212121212121212121212121212");
        BigInteger add = b1.add(b2);
        System.out.println(add);
        System.out.println(b1.subtract(b2));
        System.out.println(b1.divide(b2));
        System.out.println(b1.multiply(b2));

注意除法运算时，如果除不尽就会报错
BigDecimal divide = b1.divide(b2)
BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)
divisor:被除以的那个数
scale 要保留几位小数
roundingMode: 舍入方式
static int ROUND_UP : 向上加1
static int ROUND_DOWN 直接舍去
static int ROUND_HALF_UP 四舍五入

System.out.println(b2.divide(b3, 7, BigDecimal.ROUND_HALF_UP));

Date日期类

介绍
概述：表述特定瞬间，精确到毫秒
1秒等于1000毫秒
常用方法
long getTime() ----- 获取时间，返回毫秒值
void setTime(long Time) ------ 设置时间，从时间原点开始算起

日历类

获取：
static Calendar getInstance() ---- 获取Calendar对象的
getInstance方法底会根据不同的判断，返回不同的Calendar子类对象
常用方法
int get(int field) ------ 返回给定日历字段的值
void set(int field, int value): 将给定的日历字段设置为指定的值
void add(int field,int amount): 根据日历规则，为给定的日历i字段添加或者减去指定的时间量
Date getTime(): 将Calendar转换为Date对象

    public static void method01(){
        Calendar calendar= Calendar.getInstance();
        //int get(int field) --- 返回给定的日历字段的值
        System.out.println(calendar.get(Calendar.YEAR));
        System.out.println(calendar.get(Calendar.MONTH)+1);
    }
    public static void method02(){
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.YEAR,2000);
        System.out.println(calendar.get(Calendar.YEAR));
    }
    public static void method03(){
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.YEAR,1);
        System.out.println(calendar.get(Calendar.YEAR));
    }
    public static void method04(){
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.YEAR,2001);
        Date date = calendar.getTime();
        System.out.println(date);
    }

注意Calender的月份格式是从0开始的

SimpleDateFormat类

概述：日期格式化类（DateFormat 抽象类）
创建使用DateFormat的子类----- SimpleDateFormat
构造：
SimpleDateFormat(String pattern)
pattern: 传递的时我们指定的日期格式----- yyyy—MM–dd HH:mm:ss ------字母不能改变，但是连接符可以改变
SimpleDateFormat常用方法
String format(Date date) -------- 将Date对象按照指定的格式格式化为一个字符串
Date prase(String source) ------- 将符合日期格式的字符串转成Date对象

		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM--dd HH:mm:ss");
        String time = "2000--10--10 10:10:10";
        //将符合日期格式的字符串转成Date对象
        Date date = sdf.parse(time);
        System.out.println(date);
        final Date date1 = new Date();
        System.out.println(date1);
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM--dd HH:mm:ss");
        String time1 = sdf1.format(date1);
        System.out.println(time1);

LocalDate本地日期类（jdk8新日期类）

概述：LocalDate是一个不可变的日期时间对象，表示日期，通常被视为年月日
作用：主要是获取年月日
获取：
static LocalDate now()
static LocalDate of(int year, int month, int dayOfMonth)
LocalDateTime是一个不可变的日期时间对象，表示日期，通常被视为年月日时分秒

		LocalDate localDate = LocalDate.now();
        System.out.println(localDate);
        LocalDate localDate1 = LocalDate.of(2000,1,1);
        System.out.println(localDate1);
        LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println(localDateTime);

获取日期字段的方法，名字是get开头

int getYear() ----- 获取年份
int getMonthValue() -------获取月份
int getDayofMonth() -------获取月中的第几天

		LocalDate localDate = LocalDate.now();
        System.out.println(localDate.getYear());
        System.out.println(localDate.getMonth());
        System.out.println(localDate.getDayOfMonth());

设置日期的方法

LocalDate withYear(int year): 设置年份
LocalDate withMonth(int month): 设置月份
LocalDate withDayofMonth(int DayofMonth): 设置月中的第几天

		LocalDate localDate4 = LocalDate.now();
        LocalDate time = localDate4.withYear(2000).withMonth(11).withDayOfMonth(22);
        System.out.println(time);

日期字段偏移

设置日期字段的偏移量，方法名plus开头，向后偏移
设置日期字段的偏移量，方法名minus开头，向前偏移

		LocalDate localDate = LocalDate.now();
        System.out.println(localDate.getYear());
        ///向前偏移
        LocalDate localDate1 = localDate.minusYears(10);
        System.out.println(localDate1.getYear());
        //向后偏移
        LocalDate localDate2 = localDate.plusMonths(2);
        System.out.println(localDate2.getMonth());

Period和Duration类

period
方法
static Period between(LocalDate startDateInclusive, LocalDate endjDateExclusive) ----计算两个参数的时间偏差
作用
专门计算年月日的时间差
获取计算之后的差值
getYears() 获取相差的年
getMonths() 获取相差的月
getDays () 获取相差的天

		LocalDate localDate = LocalDate.of(2000,10,27);
        LocalDate localDate1 = LocalDate.of(2001,11,9);
        Period period = Period.between(localDate,localDate1);
        System.out.println(period.getYears());

duration
方法：stastic Duration between(Temporal startInclusive, Temporal endExclusive)
参数 temporal 接口
实现类 LocalDate，LocalDateTime
获取计算时间的差值：
toDays() : 获取相差的天数
toHours() 获取相差的天数
tohours() 获取相差分小时
toMinutes() 获取相差分钟
toMillis() 获取相差秒
主要 Duration主要是计算精确时间偏差，需要传递LocalDateTime

		LocalDateTime localDateTime = LocalDateTime.of(2000,10,27,0,0,0);
        LocalDateTime localDateTime1 = LocalDateTime.of(2001,11,9,0,0,0);
        Duration duration = Duration.between(localDateTime,localDateTime1);
        System.out.println("帅气龙和美丹相差天数为"+duration.toDays()+"天");
        System.out.println("帅气龙和美丹相差小时为"+duration.toHours()+"小时");
        System.out.println("帅气龙和美丹相差分钟为"+duration.toMinutes()+"分钟");

DateTimeFormatter日期格式化类

获取
static DateTimeFormatter ofPattern(String pattern) pattern指定的格式
方法
a.String format(TemporalAccessor temporal) ------ 将日期对象按照指定格式转成转成String
参数：TemporalAccessor：接口，是Temporal的父接口
实现类 LocalDate LocalDateTime
b.TemporalAccessor parse(CharSequence text) ------ 将符合格式的字符串日期转成日期对象
返回值：TemporalAccessor 接口，是Temporal 的父接口
实现类LocalDate LocalDateTime

		DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String time = "2000-12-12 11:11:11";
        TemporalAccessor temporalAccessor = dtf.parse(time);
        LocalDateTime localDateTime = LocalDateTime.from(temporalAccessor);
        System.out.println(localDateTime);
        LocalDateTime localDate = LocalDateTime.now();
        String time1 = dtf.format(localDate);·
        System.out.println(time1);