标签 JAVA基础 下的文章

Steam流

操作数组或集合的一个知识点
public static void main(String[] args) {
        //认识steam流
        List<String> list=new ArrayList<>();
        Collections.addAll(list,"张三1","张四","王五","赵五");

//找出姓张 并且名字是三个字的存在一个新集合中
        List<String> newList =new ArrayList<>();
        for(String s : list){
            if(s.startsWith("张") && s.length()==3){
                newList.add(s);
            }


        }
        System.out.println(newList);
        System.out.println("--------------------------");

    //使用steam流用来实现对象集合数据的操作
        List<String> listS = list.stream().filter(s -> s.startsWith("张") && s.length() == 3).collect(Collectors.toList());
        System.out.println(listS);






     //如何获取List集合的Stream流
        List<String> list1=new ArrayList<>();
        Collections.addAll(list1,"张三1","张四","王五","赵五");
        System.out.println(list1.stream());


        //如何获取Set集合的stream流
        Set<String> strings = new HashSet<>();
        System.out.println(strings.stream());

        //如何获取Map集合的Stream流
        HashMap<String, String> map = new HashMap<>();
        System.out.println(map.keySet().stream());

        System.out.println(map.values().stream());

        System.out.println(map.entrySet().stream());


        //如何获取属猪的stream流

        String[] arr={"java1","java2","java3","java4"};
        System.out.println(Arrays.stream(arr));
        System.out.println(Stream.of(arr));





    }

Date类

//1.创建日期对象
Date d = new Date();
System.out.println(d);
  
  
//2. 拿到时间戳
long time = d.getTime();
System.out.println(time);
  
  
//只获取时间戳推荐使用
//System.currentTimeMillis();
  
//3.把时间戳转为日期对象 
Date date = new Date(time);
long time1 = date.getTime();
System.out.println(time1);

  
//把时间对象的时间设置为当前时间的时间戳
xDate date1 = new Date();
date1.setTime(time);
System.out.println(date1.getTime());

SimpleDateFormat类

//SimpleDateFormat 用于格式化日期对象 变成想看到的日期格式 返回String类型
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String format = sdf.format(new Date());
System.out.println(format);


 String lastTime = "2023/05/07";
//字符串日期转换成Date日期对象
Date parse = sdf.parse(lastTime);
System.out.println(parse);

SimpleDateFormat存在的问题

/**
 *  目标:搞清楚为什么要用JDK 8开始新增的时间类。
 */
public class Test {
    public static void main(String[] args) {
        // 传统的时间类(Date、SimpleDateFormat、Calendar)存在如下问题:
        // 1、设计不合理,使用不方便,很多都被淘汰了。
        Date d = new Date();
        //System.out.println(d.getYear() + 1900);

        Calendar c = Calendar.getInstance();
        int year = c.get(Calendar.YEAR);
        System.out.println(year);

        // 2、都是可变对象,修改后会丢失最开始的时间信息。

        // 3、线程不安全。

        // 4、不能精确到纳秒,只能精确到毫秒。
        // 1秒 = 1000毫秒
        // 1毫秒 = 1000微妙
        // 1微妙 = 1000纳秒
    }
}

精度丢失

//精度丢失
System.out.println(0.1+0.2);
System.out.println(1.0-0.32);
System.out.println(1.015*100);
System.out.println(1.301/100);

BigDecimal

//注意new出来的 BigDecimal() 括号写字符串
BigDecimal b1=new BigDecimal("1.2");
//使用valueOf()
BigDecimal b2=BigDecimal.valueOf(1.2);

//求和
System.out.println(b2.add(b1));
//减
System.out.println(b2.subtract(b1));
//相乘
System.out.println(b2.multiply(b1));
//除
System.out.println(b2.divide(b1));

//算数异常
//当除不尽时会报错
BigDecimal b3=BigDecimal.valueOf(1);
BigDecimal b4=BigDecimal.valueOf(3);
//报错
System.out.println(b3.divide(b4));
//解决方案
//四舍五入
System.out.println(b3.divide(b4, RoundingMode.HALF_UP));
//向上取整
System.out.println(b3.divide(b4, RoundingMode.CEILING));
//向下取整
System.out.println(b3.divide(b4, RoundingMode.FLOOR));

保留小数位

System.out.println(b3.divide(b4,2, RoundingMode.FLOOR));

把BigDecimal转换为doubleValue

double doubleValue=b5.doubleValue();

//终止java虚拟机
System.exit(0);

//获取系统当前戳
//1970.1.1  00:00:00 到当前时间的毫秒
System.currenTimeMillis();

//求这段代码时间用了多少时间
long t1=System.currenTimeMillis();
long t2=System.currenTimeMillis();
System.out.println(t2-t1);

//绝对值
Math.abs(123);
//向上取整
Math.ceil(1.1);
//向下取整
Math.floor(2.3);
//四舍五入
Math.round(3.45);
//最大最小值
Math.max(100,2);
Math.min(3,1000);

//StringBuilder的创建
StringBuilder sb=new StringBuilder("java")

//拼接内容 append(String s);
sb.append("123");

//支持链式编程
StringBuilder sb1=new StringBuilder("张三");
sb1.append("李四").append("王五");
System.out.println(sb1);
//反转操作 reverse()
sb1.reverse();

//返回字符串长度 length()
System.out.println(sb1.length());

//把StringBuilder对象转换成String 类型 .toString();

String s=sb1.toString();

StringBuider的好处

比String拼接字符串的效率快

基本数据类型对应的包装类(引用数据类型)
byteByte
shortShort
intInteger
longLong
chatCharacter
floatFloat
doubleDouble
booleanBoolean

Integer对象的创建

1. new 有参
Integer a=new Integer(123);
2. 静态方法 valueOf()
Integer b=Integer.valueOf(20);
3. 自动装箱写法 (java自动把基本数据类型对应的包装类)
Integer c=30; //Integer.valueOf(30)

//4.自动拆箱(java自动把包装类装维基本数据类型)
int d=c;

泛型
//ArrayList<String>
//集合内只能装String类型的数据
//泛型的作用 在编译阶段 检查集合的元素的类型
//在java1.7开始 泛型后面的部分可以不写
ArrayList<String> list1=new ArrayList<>();
list1.add("123");
list1.add("字符串");

泛型类

格式
/**
 * 自定义泛型类
 * @author TongHui
 * @date 2023.05.04 15:33
 * @param <E> 我的集合中的元素类型
 */
public class MyArrayList <E>{
    private Object[] array=new Object[10];
    private int index;

    /**
     * 添加元素
     * @param e
     */
    public void add(E e){
        array[index]=e;
        index++;
    }

    /**
     * 获取元素
     * @param index
     * @return
     */
    public E get(int index){
        return (E) array[index];
    }
}
public class Test {
    public static void main(String[] args) {
        MyArrayList<String> stringMyArrayList = new MyArrayList<>();
        stringMyArrayList.add("123123");
        System.out.println(stringMyArrayList.get(0));
    }



    public static <T> void test(T t){
        System.out.println(t.toString());
    }

    public static <T> T test2(T t){
        return t;
    }

}

枚举时一个特殊的类,他的格式是:
public enum 枚举类名{
    枚举项1,枚举项2,枚举项3;
}

其实枚举项就表示枚举类的对象,只是这些对象在定义枚举类时就预先写好了,以后就只能用这几个固定的对象。

案例

public enum A{
    X,Y,Z;
}
想要获取枚举类中的枚举项,只需要用类名调用就可以了
public class Test{
    public static void main(String[] args){
        //获取枚举A类的,枚举项
        A a1 = A.X;
        A a2 = A.Y;
        A a3 = A.Z;
    }
}

枚举项是当前这个枚举

枚举项是static修饰的

枚举项被finale修饰

枚举的应用场景

API响应
public enum ResponseCodeEnum{
    //成功 返回SUCCESS信息 和 200状态码
    //失败 返回ERROR 信息 和 500状态码
    SUCCESS(200,"SUCCESS"),
    ERROR(500,"ERROR")
    ;
    //枚举有参构造器 为什么要提供无参?
    //只想用有参枚举项
    private int code;
    private String desc;
    ResponseCodeEnum(int code,String desc){
        this.code=code;
        this.desc=desc;
    }
    public int getCode(){
        return code;
    }
    public String getDesc(){
        return desc;
    }
}

[scode type="green" size=""]类中的五大成分之一(成员变量、方法、构造器、内部类、代码块),如果一个类定义在另一个类的内部,这个类就是内部类。[/scode]

public class Test {
    public static void main(String[] args) {
        //Car car=new Car();
        //Engin engine =car.new Engine()

        //1.几乎用不到
        //2.先new出来外部类new 对象.new 内部类
        Car.Engine engine = new Car().new Engine();
        engine.fire();
    }
}

class Car {
  
    public static String brand="马自达";
    String name="2023新款马自达";
    //内部类
    public class Engine {
        String name="雕牌引擎";
  
        public void fire(){
            String name="马氏点火";
            System.out.println(name);
            System.out.println(this.name);
            //调用外部类的变量方法
            System.out.println(Car.this.name);
        }
    }
}

内部类使用场景

定义在另一个类中的类,它体现了一种代码的隐藏机制和访问控制机制。当往往只有外部类调用此类时,所以就没必要专门设置一个JAVA文件存放这个类。

内部类特点

总结一下内部类访问成员的特点

既可以访问内部类成员、也可以访问外部类成员

如果内部类成员和外部类成员同名,可以使用类名.this.成员区分

静态内部类

使用static修饰内部类
public class Outer{
  public int age=100;
  public static String schoolName="北大";
  //静态内部类
  public static class Inner{
     public void test(){
       //静态内部类不能访问外部实例成员
   
      //静态内部类可以访问外部静态成员
      System.out.println(schoolName);
     }
  }
}

局部内部类

定义在方法里面的类
public class Student{
  public void study(){
   //局部内部类:定义在外部类中的方法中 
   //只能在外部类之中创建对象
   class Mobie{
     public void test(){
       System.out.prinln("局部内部类Mobile,test方法执行了")
    }
   }
  }
}

匿名内部类

匿名内部类是一种特殊的局部内部类;所谓匿名,指的是程序员不需要为这个类声明名字。
public class Test{
    public static void main(String[] args){
        //定义一,定义子类继承父类 实现抽象方法
        Animal a1=new Dog();
        a1.say();
        //方法二 不定义子类 用匿名内部类写法
        Animal a2=new Animal(){
            @Override
            public void say(){
                System.out.println("kkkkk");
            }
        };
        a2.say();
        animalPkSay(new Animal() {
            @Override
            public void say() {
                System.out.println("鹅鹅鹅饿");
            }
        });
    }
  
    public static void animalPkSay(Animal animal){
        animal.say();
    }
}
abstract class Animal{
    String name;
    public abstract void say();
}
class Dog extends Animal{
    @Override
    public void say(){
        System.out.println("汪汪");
    }
}

匿名内部类的使用场景

方法参数是抽象类或者接口时 可以使用匿名内部类简化写法

如果方法实现简单 推荐使用匿名内部类 如果方法实现复杂 推荐定义子类