JavaSE-常用类、Stream 流式计算

  • 常用类
    • 内置包装类
      • Integer
    • String
      • 类型转换
    • StringBuilder（JDK1.5）
    • StringBuffer（JDK1.0）
    • Date（JDK1.0）
      • 拓展：System.currentTimeMills
    • DateFormat
    • Calendar（JDK1.1）
    • LocalDate、LocalTime、LocalDateTime（JKD1.8）
    • DateTimeFormatter（JDK1.8）
    • Math
    • Random
    • 枚举
  • Stream 流式计算

常用类

内置包装类

基本数据类型对应的包装类

  • byte Byte

  • short Short

  • int Integer

  • long Long

  • float Float

  • double Double

  • char Character

  • boolean Boolean

Integer

类结构

构造器声明：

Integer i = new Integer(12);
Integer i2 = new Integer("12"); //String--->Integer

  1. 构造器参数为int 类型时

  2. 构造器参数为String 类型时

常用属性：

Integer.MAX_VALUE  //返回int类型的最大范围
Integer.MIN_VALUE  //返回int类型的最小范围

自动拆装箱：

// 自动装箱
Integer i = 12;  //int--->Integer，实际上是调用了Integer.valueOf(12);
// 自动拆箱
Integer i2 = new Integer(12);
int i3 = i2;  //Integer--->int，实际上调用了i2.intValue();

缓冲数组：

public class Demo{public static void main(String[] args){Integer i = 12;Integer i2 = 12;System.out.println(i==i2); //trueSystem.out.println(i.equals(i2));  //trueInteger i3 = 129;Integer i4 = 129;System.out.println(i==i2); //falseSystem.out.println(i.equals(i2));  //true/*== 比较的左右两侧的数值：数值在-128~127之间：比较的是就是数（在缓冲数组中的数）。数值不在-128~127之间：底层就创建对象  ==比较的就是左右的地址值。源码发现valueOf 具有缓冲范围*/}
}

常用方法：

public class Demo{public static void main(String[] args){Integer i = new Integer(12);Integer i2 = new Integer(12);int res = i.compareTo(i2);  // 比较System.out.println(i==i2);  //=> false，原因地址指向不同System.out.println(i.equals(i2));  //=> true，源码：return value==((Integer)obj).intValue();System.out.println(res);   //=> 0，源码：return (x<y)?-1:((x==y)?0:1);int num = Integer.parseInt("12");  // String--->intString num2 = i.toString();  // Integer--->StringSystem.out.println(num2);  //=> "12"}
}

String

特点

  1. 不能被继承。类被final 修饰

  2. String底层就是char类型的数组

  1. 不可变：在地址不变的情况下不可以修改字符串的值。

定义String类型：

public class Main{public static void main(String[] args){// 定义String类型变量String name = "haha";String name2 = new String("haha");String name2 = new String(new char[]{'h','a','h','a'});  // 底层就是给value数组赋值。}
}

常用方法：

public class Main{public static void main(String[] args){// 定义String类型变量String name = "haha";String name2 = new String("haha");String name3 = new String("hbha");int num = name.length();  // 获取字符串长度boolean bool = name.isEmpty();  // 判断字符串是否为空char a = name.charAt(3);  // 返回字符串对应下标的字符boolean bool2 = name.equals(name2);  // 判断字符串相等int num2 = name2.compareTo(name3);  // 获取两字符串的就近差值（Ascii 码的差值/字符长度的差值）String newStr = name.substring(1,[endIndex]);  // 截取字符串下标位到末尾[endIndex]的字符串String newStr2 = name.concat(name2);  // 拼接字符串String newStr3 = name.replace('a','j');  // 字符替换boolean bool3 = name.contains('a');  // 判断字符串是否包含字符、字符串String name4 = new String("h-a-h-a");String[] arr = name4.split('-');  // 分割字符串String newStr4 = name.toUpperCase().toLowerCase();  // 大小写转换String newStr5 = name.trim();  // 首尾去空}
}

源码分析equals() 与 compareTo() 方法

String 内存空间说明

public class HelloWorld {public static void main(String []args) {String a = "haha";String b = new String("haha");String c = "ha" + "ha";String e = "ha";String d = e + "ha";String f = new String("haha");System.out.println(a==c);  // trueSystem.out.println(a==d);  // falseSystem.out.println(a==b);  // falseSystem.out.println(b==c);  // falseSystem.out.println(b==f);  // false}
}

  1. 给定字符的拼接，会进编译器的优化，直接拼接成完整的字符串，直接在方法区常量池中开辟空间，然后地址给了栈中的变量，不会在堆中开辟空间。并且常量池的特点是第一次如果没有就开辟空间，如果存在就不开辟。

  2. 使用new关键字创建的对象就会在堆中开辟空间。（值可以从常量池中取）

  3. 有变量参与运算的字符串拼接会在堆中开辟空间，通过反汇编得知有变量参与运算的字符串会实例化StringBuilder。

类型转换

String to char[]

public static void stringToChar(String str){char[] str_char_arr = str.toCharArray();
}

源码:

public char[] toCharArray() {// Cannot use Arrays.copyOf because of class initialization order issueschar result[] = new char[value.length];System.arraycopy(value, 0, result, 0, value.length);  // 数组复制return result;}

char[] to String

public static void charToString(){char[] chars = {'1','2','3','4','5','6'};String str1 = new String(chars);            //通过String构造函数String str2 = String.valueOf(chars);     //通过String类型转换，实际也是new String(char[])
}

char[] to List

public static void arrayToList(){Character[] chars = {'1','2','3','4','5','6','7','8','9'};//方式一List<Character> list1 = Arrays.asList(chars); //通过Arrays的工具类//方式二List<Character> list2 = new ArrayList<>();   //通过Collections工具类Collections.addAll(list2,chars);}

String to List

 //原理就是首先将String转换成String[]数组，再通过工具类转换为Listpublic static void stringToList (String str){String str1 = "123456";//方式一List<String>list1  = Arrays.asList(str.split("")); //str.split()返回一个String[]数组//方式二List<String>list2 = new ArrayList<>();Collections.addAll(list2, str.split(""));}

List to String

public static void listToString(){List<String> list = Arrays.asList("1","2","3","4");String str = String.join("", list); //"1234"
}

List to Set to List

public static void listToSet(){List<String> list = new ArrayList<>();Set<String> set = new HashSet<>(list);   //直接构造函数即可
}

 public static void setToList(){Set<String> set = new HashSet<>();List<String> list = new ArrayList<>(set); //直接构造函数即可
}

String to Set to String

 public static void stringToSet(){String str = "12345";String[] strs= str.split("");//方式一List<String> list1 = Arrays.asList(strs);Set<String> set1 = new HashSet<>(list1);//方式二Set<String> set2 = new HashSet<>();Collections.addAll(set2, strs);}

 public static void setToString(){Set<String> set = new HashSet<>();String.join("", set);}

StringBuilder（JDK1.5）

特点

  1. 可变：由于在构建中一直返回的是当前的类对象所以在地址不变的情况下是可以修改字符串的值。
public class Demo{public static void main(String[] args){StringBuilder str = new StringBuilder("abc");str.append("ttttttt");str.append("vvvvvvvvvvvvvvvvv");System.out.println(str);}
}

  1. StringBuilder 底层就是一个char类型的数组。

  2. 调用空构造器默认新建16个空元素的char类型数组。

  3. 执行流程：（源码分析）

  • 执行new StringBuilder(“abc”) 返回19 位字符数组
// public final class StringBuilder extends AbstractStringBuilder implements java.io.Serializable, CharSequence
// 1. 构建初始化数组（value："abc"）,返回长度为19的空字符数组。// AbstractStringBuilder.javaAbstractStringBuilder(int capacity) {value = new char[capacity];}// StringBuilder.javapublic StringBuilder(String str) {super(str.length() + 16);append(str);}

// 2. 调用append方法，判断是否增容，调用getChars进行复制，并且保存内存空间使用计数// AbstractStringBuilder.javapublic AbstractStringBuilder append(String str) {if (str == null)return appendNull();int len = str.length();ensureCapacityInternal(count + len);   // 0+3str.getChars(0, len, value, count);count += len;return this;}// StringBuilder.javapublic StringBuilder append(String str) {super.append(str);return this;}

// 3. 调用ensureCapacityInternal判断是否决定增容// AbstractStringBuilder.javaprivate void ensureCapacityInternal(int minimumCapacity) {// overflow-conscious codeif (minimumCapacity - value.length > 0) {value = Arrays.copyOf(value,newCapacity(minimumCapacity));}}

// 4. 根据形参将value复制到长度为19的数组中。（0，3，[null....*19]，0）
// String.javapublic void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {if (srcBegin < 0) {throw new StringIndexOutOfBoundsException(srcBegin);}if (srcEnd > value.length) {throw new StringIndexOutOfBoundsException(srcEnd);}if (srcBegin > srcEnd) {throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);}System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);}

  • 再调用 str.append(“ttttttt”);
// 1. 调用append方法，判断是否增容，调用getChars进行复制，并且保存内存空间使用计数// AbstractStringBuilder.javapublic AbstractStringBuilder append(String str) {if (str == null)return appendNull();int len = str.length();ensureCapacityInternal(count + len);   // 3+7str.getChars(0, len, value, count);count += len;return this;}// StringBuilder.javapublic StringBuilder append(String str) {super.append(str);return this;}

// 2. 根据形参将value复制到长度为19的数组中。（0，7，[a,b,c,null....*16]，3）
// String.javapublic void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {if (srcBegin < 0) {throw new StringIndexOutOfBoundsException(srcBegin);}if (srcEnd > value.length) {throw new StringIndexOutOfBoundsException(srcEnd);}if (srcBegin > srcEnd) {throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);}System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);}
  • 再调用 str.append(“vvvvvvvvvvvvvvvvv”);
// 1. 调用append方法，判断是否增容，调用getChars进行复制，并且保存内存空间使用计数// AbstractStringBuilder.javapublic AbstractStringBuilder append(String str) {if (str == null)return appendNull();int len = str.length();ensureCapacityInternal(count + len);   // 10 + 17str.getChars(0, len, value, count);count += len;return this;}// StringBuilder.javapublic StringBuilder append(String str) {super.append(str);return this;}

// 2. 调用ensureCapacityInternal 增容，返回一个长度位 newCapacity(minimumCapacity) 的字符数组// AbstractStringBuilder.javaprivate void ensureCapacityInternal(int minimumCapacity) {// overflow-conscious codeif (minimumCapacity - value.length > 0) {    27 > 19 ? truevalue = Arrays.copyOf(value,newCapacity(minimumCapacity));}}private int newCapacity(int minCapacity) {// overflow-conscious codeint newCapacity = (value.length << 1) + 2;  // (19<<1)+2=40if (newCapacity - minCapacity < 0) { // 40-27<0?falsenewCapacity = minCapacity;}return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)? hugeCapacity(minCapacity): newCapacity;  //return 40;}

// 3. 根据形参将value复制到长度为27的数组中。（0，17，[a,b,c,t,t,t,t,t,t,t,null....*...]，10）
// String.javapublic void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {if (srcBegin < 0) {throw new StringIndexOutOfBoundsException(srcBegin);}if (srcEnd > value.length) {throw new StringIndexOutOfBoundsException(srcEnd);}if (srcBegin > srcEnd) {throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);}System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);}

常用方法

public class Main{public static void main(String[] args){StringBuilder str = new StringBuilder("abc");// 增str.append("def");// 删str.delete(0,2);  // 删除[0,2)下标的字符str.deleteCharAt(2);  // 删除指定下标的字符// 改str.insert(1,',');  // 指定下标前插入str.replace(1,2,'hh');  // 在下标[1,2)位置上替换字符str.setCharAt(3,"2");  // 替换指定位置字符// 查for(int i = 0; i< str.length(); i++){char c = str.charAt(i);}String s = str.substring(2,4);   // 截取[2,4)返回一个新的String类型数据，对StringBuilder无影响。}
}

理解什么是可变字符串，什么是不可变字符串？

String：在地址不变的情况下不可以修改字符串的值。

StringBuilder、StringBuffer：在地址不变的情况下可以修改字符串的值。

判定不可变和可变的前提是地址不变。String为什么是不可变字符串？因为String类型的值在堆中发生改变就要重建索引。而StringBuilder不同，只有唯一的引用地址，变得只是引用地址中的属性。

所以也可以解释为什么？StringBuilder sb = new StringBuilder(); System.out.print(sb.append(“def”)==sb.append(“abc”)); // true

StringBuffer（JDK1.0）

功能类似于StringBuilder

JDK 1.5新增了一个StringBuilder类，与StringBuffer相似，构造方法和基本方法基本相同。不同的是StringBuffer考虑了线程安全问题，而StringBuilder没考虑，所以StringBuffer线程安全，StringBuilder线程不安全，因此StringBuilder性能略高，通常情况下，创建一个内容可变的字符串应该考虑使用StringBuilder

StringBuffer：JDK1.0 效率低 线程安全

StringBuilder：JDK1.5 效率高 线程不安全

Date（JDK1.0）

sql 包下的Date 继承 util 包下的 Date

import java.util.Date;  // 年月日时分秒
import java.sql.Date;  // 年月日
public class Main{public static void main(String[] args){Date date = new Date();date.getTime();  // 获取时间戳// util ---> sqljava.sql.Date date2 = new java.sql.Date(date.getTime());  // 返回 年-月-日 格式数据// sql ---> utilDate date = date2// String ---> java.util.Date// 1. String to java.sql.Date// 2. java.sql.Date to java.util.Datejava.sql.Date date3 = new java.sql.Date.valueOf("2021-5-28");java.util.Date date4 = date3;}
}

上面的代码字符串参数具有局限性，只能是xxxx-xx-xx 格式的参数否则报错：

所以引入日期格式化的类：DateFormat

https://blog.csdn.net/qq_40915081/article/details/80298176

https://www.cnblogs.com/zhujiabin/p/6168671.html?utm_source=itdadao&utm_medium=referral

拓展：System.currentTimeMills

获取时间戳的方法：

  1. new Date().getTime(); 在不考虑时区时，使用此方法获取时间戳会有性能上的损耗因为需要实例化对象，但是在需要考虑时区问题时只能使用此方法获取时间戳。

  2. System.currentTimeMillis(); 从源码 public static native long currentTimeMillis() 看这是一个调用非java代码的接口，其时间来源依赖为其做了时区的处理，因此获取时间戳，在不考虑时区的情况下，他是最优选择。

  3. Calendar.getInstance().getTimeInMillis()

DateFormat

注意：DateFormat 是一个抽象类不能被实例化，所以需要实例化其子类 SimpleDateFormat。

public class Main{public static void main(String[] args){// 定义格式DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// String ---> Datetry{Date date = df.parse("2021-5-28 14:01:31");}catch(ParseException e){e.printStackTrace();}// Date ---> StringString str = df.format(new Date());}
}

Calendar（JDK1.1）

日历类Calender 是一个抽象类不能直接实例化，所以只能实例化其子类GregorianCalender。

public class Demo{public static void main(String[] args){// 实例化对象方法：两种Calendar cal1 = new GregorianCalendar();// Calendar cal2 = Calendar.getInstance()// 常用方法 get(参入Calender中定义的常量)cal1.get(Calendar.YEAR);  // 获取年份需要+1900cal1.get(Calendar.MONTH); // 获取月份，从0开始所以要+1cal1.get(Calendar.DATE); // 获取日期cal1.get(Calendar.DAY_OF_WEEK); // 获取星期cal1.getActualMaximum(Calendar.DATE); // 获取这月的最大天数cal1.getActualMinimum(Calendar.DATE); // 获取这月的最小天数// set 设置日历cal1.set(Calendar.YEAR,2020);// setTime(Date date)}
}

打印一个日历

import java.util.Calendar;
import java.util.Scanner;public class Demo01 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.print("请输入查询的日期：");if (sc.hasNextLine()) {String str = sc.nextLine();java.sql.Date date = java.sql.Date.valueOf(str);Calendar cal = Calendar.getInstance();cal.setTime(date);System.out.println("日\t一\t二\t三\t四\t五\t六\t");// 获取输入日期当月的最大天数然后进行遍历int maxDate = cal.getActualMaximum(Calendar.DATE);// 获取当前天数后面加上*int nowDate = cal.get(Calendar.DATE);int count = 0;// 获取对应日期对应的星期数，实际上就是每月1号前的空格cal.set(Calendar.DATE, 1);int num = cal.get(Calendar.DAY_OF_WEEK) - 1;for (int i = 0; i < num; i++) {System.out.print(" \t");}count += num;for (int i = 1; i <= maxDate; i++) {if (i == nowDate) {System.out.print(i + "*\t");} else {System.out.print(i + "\t");}count++;if (count % 7 == 0) {System.out.println();}}}sc.close();}
}

LocalDate、LocalTime、LocalDateTime（JKD1.8）

LocalDate（本地日期）LocalTime（本地时间）

  1. 方法一：now() 获取现在相关的日期、时间、日期时间。
public class Demo{public static void main(String[] args){LocalDate localDate = LocalDate.now(); // 2021-12-16LocalTime localTime = LocalTime.now(); // 14:00:00.000LocalDateTime localDateTime = LocalDateTime.now(); // 2021-12-16T14:00:00.000}
}
  1. 方法二：of() 设置指定日期、时间、日期时间。
public class Demo{public static void main(String[] args){LocalDate of1 = LocalDate.of(2021,12,16);  LocalTime of2 = LocalTime.of(18,16,15);LocalDateTime of3 = LocalDate.of(2021,12,16,18,16,15);}
}

LocalDate（本地日期）LocalTime（本地时间）用得不是特别多。

LocalDateTime（本地日期时间）详解

获取：get

public class Demo{public static void main(String[] args){localDateTime.getYear();  // 获取年localDateTime.getMonth(); // 获取月localDateTime.getMonthValue(); // 获取月数值localDateTime.getDayOfMonth(); // 获取天数localDateTime.getDayOfWeek(); // 获取星期数... getXXX();}
}

设置：with

public class Demo{public static void main(String[] args){localDateTime.withYear(2022);  // 设置年，会重新返回一个LocalDateTime 类型的数据... withtXXX();}
}

加减操作：plus/minus XXX()

类比，还是会重新返回LocalDateTime 类型的数据

DateTimeFormatter（JDK1.8）

在jdk 1.8 后出现了一个与DateFormat类似的类DateTimeFormatter

使用方法

public class Demo{public static void main(String[] args){// 实例化DateTimeFormatter，三种方式：// 1. 预定义标准格式：ISO_LOCAL_DATE,ISO_LOCAL_TIME,ISO_LOCAL_DATE_TIMEDateTimeFormatter df1 = DateTimeFormatter.ISO_LOCAL_DATE_TIME;// 这个格式化类可以将LocalDateTime 转换成StringLocalDateTime localDateTime = LocalDateTime.now();String str = df1.format(localDateTime);  // 将当前日期时间打印出来TemporalAccessor parseTime = df1.parse("2021-12-16T14:00:00.000");  // 将字符串打印成日期时间// 2. 本地化相关格式：ofLocalizedDateTime([FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT]);// FormatStyle.LONG：xxxx年xx月xx日 上/下午xx时xx分xx秒// FormatStyle.MEDIUM：xxxx-xx-xx xx:xx:xx// FormatStyle.SHORT：xx-xx-xx 上/下午xx:xxDateTimeFormatter df2 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM);LocalDateTime localDateTime2 = LocalDateTime.now();String str2 = df2.format(localDateTime2); // 根据填入的参数格式，将当前日期时间打印出来TemporalAccessor parseTime2 = df2.parse(str2); // 根据填入的参数格式，将当前字符串打印成日期时间3. 方式三：自定义格式：ofPattern("yyyy-MM-dd HH:mm:ss")DateTimeFormatter df3 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");LocalDateTime localDateTime3 = LocalDateTime.now();String str3 = df3.format(localDateTime3); // 根据填入的参数格式，将当前日期时间打印出来TemporalAccessor parseTime3 = df3.parse(str3); // 根据填入的参数格式，将当前字符串打印成日期时间}
}

Math

// 静态导入，可以将类名省略，然后import + static + 那个包下的哪个类下的所有内容（*）
// 静态导入后，本类中有同名的方法，优先调用本类的方法
import static java.lang.Math.*;
public class Main{public static void main(String[] args){System.out.println(Math.random());  //=> 随机数[0.0 1.0)System.out.println("绝对值" + Math.abs(-9));  //=> 9System.out.println("四舍五入" + Math.round(9.1));  //=> 9System.out.println("向上取整" + Math.ceil(9.1));  //=> 10System.out.println("向下取整" + Math.floor(9.1));  //=> 9System.out.println("最大值" + Math.max(9,10));  //=> 10System.out.println("最小值" + Math.min(9,10));  //=> 9System.out.println("次幂" + Math.pow(2,2));  //=> 4}
}

Random

public class Main{public static void main(String[] args){// 定义有参构造器，每次传入的参数只要是一样的那么产生的结果也是一样的。如要想要产生的随机数不一样我们就必须传入不一样的种子Random r = new Random(System.currentTimeMillis());// 定义无参构造器，就不用传种子Random r2 = new Random();r2.nextInt(10); // [0,10)的随机数}
}

r2.nextDouble() 与Math.random() 间的关系：

枚举

定义枚举类的关键字是 enum，所有的枚举都是隐性继承于Java.lang.Enum。枚举实际上还是一个类，而每个被类枚举的成员实质就是一个枚举类型的实例，他们默认都是public static final。可以直接通过枚举类直接使用。

// Gender.java
public enum Gender{男,女;
}// Demo.java
public class Demo{public static void main(String[] args){Demo demo = new Demo();demo.setName('xiaoming');demo.setAge(10);demo.setSex(Gender.男);System.out.println(demo.toString());}// 定义一个构造器public Demo(){}private String name;private int age;private String sex;// 重载public Demo(String name,int age,Gender sex){this.name = name;this.age = age;this.sex = sex;}// 私有属性的get和setpublic String getName(){return name;}public int getAge(){return age;}public Gender getSex(){return sex;}public void setName(String name){this.name = name;}public void setAge(int age){this.age = age;}public void setSex(Gender sex){this.sex = sex;}// 重写toString方法@Overridepublic String toString(){return "Student{" + "age="+age+", name='"+name+'\''+", sex='"+sex+'\''+'}';}
}

Stream 流式计算

import java.util.Arrays;
import java.util.List;class User {private int age;private String name;private int id;public User(int age, String name, int id) {this.age = age;this.name = name;this.id = id;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getId() {return id;}public void setId(int id) {this.id = id;}@Overridepublic String toString() {return "User{" +"age=" + age +", name='" + name + '\'' +", id=" + id +'}';}
}public class Demo {public static void main(String[] args) {// 流式计算List<User> users = Arrays.asList(new User(21, "a", 1), new User(22, "b", 2), new User(23, "c", 3),new User(24, "d", 4), new User(25, "e", 5));// 链式编程users.stream().filter((u) -> {return u.getId() % 2 == 0;}).filter((u) -> {return u.getAge() > 23;}).map((u) -> {// 传入一个类型数据，返回其他类型数据return u.getName().toUpperCase();}).sorted((uu1, uu2) -> {return uu2.compareTo(uu1);}).limit(1).forEach(System.out::println);}
}

JavaSE-常用类、Stream 流式计算相关推荐

  1. java8/Stream流式计算从入门到精通/函数式编程实战

    摘要:Stream流式计算,本文讲解了Stream流式计算的概念,具体的使用步骤以及源码实现,最后讲解了使用Stream过程中需要注意的事项.Stream在公司项目中被频繁使用,在性能优化上具有广泛的 ...

  2. Stream流式计算

    一.什么是Stream流式计算(学习此之前,要先知道四大函数式接口) 1.常用的集合是为了存储数集,而对于集合数据的一些处理(像筛选集合数据等)可以使用Stream流来处理         2.jav ...

  3. Java stream流式计算详解

    Java stream流式计算详解 1. Stream概述 1.1 Stream简介 1.2 Stream分类 2. Stream操作 2.1 Stream创建 2.2 Stream无状态操作 2.3 ...

  4. mysql流式计算,Stream流式计算

    Stream流式计算 什么是Stream流式计算 数据处理中不可缺少的两部分:存储 + 计算 集合.MySQL本质就是存储数据的,计算都应该交给流来操作! package com.kuang.stre ...

  5. [编程] Java8 Stream(流式计算) 常见的一些用法汇总

    前提:以下基于 List<Student> 列表进行举例,大家实际使用进行举一反三即可.大同小异,Java8 的流式计算功能很强大,需要大家实际应用中逐渐挖掘更高级的用法. Student ...

  6. 专访阿里云高级技术专家吴威：Kafka、Spark和Flink类支持流式计算的软件会越来越流行...

    杭州·云栖大会将于2016年10月13-16日在云栖小镇举办,在这场标签为互联网.创新.创业的云计算盛宴上,众多行业精英都将在这几天里分享超过450个演讲主题. 为了帮助大家进一步了解这场全球前言技术 ...

  7. Steram流式计算学习笔记

    Steram流式计算 一.概述 说到Stream便容易想到 I/O Stream,而实际上,谁规定"流"就一定是"I0流"呢 ?在Java 8中,得益于Lamb ...

  8. java流式计算学习笔记

    Java Stream流式计算:Java 8 API添加了一个新的抽象称为流Stream,可以让你以一种声明的方式处理数据. Stream API可以极大提高Java程序员的生产力,让程序员写出高效率 ...

  9. java1.8 流式计算：利用接口的函数式编程 + 链式编程

    java1.8 流式计算:利用接口的函数式编程 + 链式编程 文章目录 java1.8 流式计算:利用接口的函数式编程 + 链式编程 1.流式计算 1)ArrayList和Stream关联的底层解析( ...

最新文章

  1. ASP.NET中常用的文件上传下载方法
  2. 117. Populating Next Right Pointers in Each Node II
  3. POJ - 2513 Colored Sticks(字典树+并查集+欧拉回路)
  4. 我所了解的Chrome
  5. 开发、测试与QA的区别以及其他
  6. 8、mybatis中的sql映射文件详解（3）
  7. myeclipse mysql连接_MyEclipse连接Mysql数据库的方法（一）
  8. 菜鸟车辆路径规划创造26项世界纪录 实际可降低10.3%配送成本
  9. Springboot01创建第一个程序
  10. python能做什么项目-Python可以做大项目吗？
  11. 记一次route配置不起作用的问题解决过程
  12. layui表单元素的radio单选框问题
  13. 多继承完美闪避成员名冲突的问题
  14. Matlab R2020a版安装下载详细操作步骤【Matlab 140期】
  15. 几个值得收藏windows软件
  16. 51单片机学习--数字时钟数字电压表
  17. 利用cookie实现登陆知网与抽屉网 基于session自动登录抽屉网 cookie与session区别
  18. 数据的距离度量 一、欧式距离，曼哈顿距离，闵氏距离，切比雪夫距离，兰氏距离，马氏距离
  19. 联想t168服务器硬盘,联想万全T168服务器板载Sata+raid系统设置图解.doc
  20. 使用HTML+CSS写一个静态页面

热门文章

  1. 【CTF】【winhex】超详细jpg图片结构分析
  2. rs232发送数据程序c语言,RS-232C详解.pdf
  3. Attention注意力机制学习（二）-------＞一些注意力网络整理
  4. android混淆语法(android代码混淆工具)
  5. 莱昂纳多(Leonardo)方程求解计算国土面积 （matlab程序答案）
  6. oracle 主键 删除表_ORACLE中添加删除主键
  7. 【小红书排名规则】社区规则、账号权重、笔记权重和推荐规则
  8. 全球与中国椰子提取物市场深度研究分析报告
  9. ElementUI分页功能
  10. 程控交换机分机同时拨打外线的方法