Java API

API（Application Programming Interface）指的是应用程序编程接口。
String类
String初始化有两种，一个是使用字符串常量初始化一个String对象，
String str = “abc”;
还有一种是使用String构造方法初始化字符串，
public class Test{
    public static void main(String[] args) {
        String str1 = new String(); //创建一个空字符串
        String str2 = new String("abcd");   //创建一个内容为abcd的字符串
        char[] ch = new char[]{'A','B','C','D'};    //创建数组
        String str3 = new String(ch);       //创建一个内容为字符数组的字符串
        System.out.println(str1+"|"+str2+"|"+str3);
    }
}
运行结果
|abcd|ABCD
 
“==”和“equals()”区别
都可以通过这两种方式对字符串进行比较。equals()方法用于比较两个字符串中的字符是否相等；==方法用于比较字符串对象的地址是否相同。
 
public class Test{
    public static void main(String[] args) {
       String a = "abc";
       String b = "abc";
        System.out.println(a.equals(b));
        System.out.println(a==b);
    }
}
运行结果
true
true
当创建两个字符串对象时，
public class Test{
    public static void main(String[] args) {
       String a = new String("abc");
       String b = new String("abc");
        System.out.println(a.equals(b));
        System.out.println(a==b);
    }
}
运行结果
true
false
StringBuffer类
StringBuffer类和String类最大的区别在于它的内容和长度是可以改变的。StringBuffer在其中添加和删除字符时，并不会产生新的StringBuffer对象。
public class Test{
    public static void main(String[] args) {
        System.out.println("1.添加----------");
        add();
        System.out.println("2.删除----------");
        remove();
        System.out.println("3.修改----------");
        alter();
    }
    public static void add(){
        StringBuffer sb = new StringBuffer();   //定义一个字符串缓冲区
        sb.append("abcdefg");   //在末尾添加字符串
        System.out.println("append添加结果："+sb);
        sb.insert(2,"123"); //在指定位置插入字符串
        System.out.println("insert添加结果："+sb);
    }
    public static  void remove(){
        StringBuffer sb = new StringBuffer("abcdefg");  //创建一个非空的字符串对象
        sb.delete(1,5); //指定范围删除
        System.out.println("delete删除结果："+sb);
        sb.deleteCharAt(2); //指定位置删除
        System.out.println("deleatCharAt删除结果："+sb);
        sb.delete(0,sb.length());   //清空缓冲区
        System.out.println("delete清空缓冲区结果："+sb);
    }
    public static void alter(){
        StringBuffer sb = new StringBuffer("abcdef");
        sb.setCharAt(1,'p');    //修改指定位置字符
        System.out.println("setCharAt修改指定位置字符结果："+sb);
        sb.replace(1,2,"qq");   //替换指定位置字符或字符串
        System.out.println("replace替换指定位置字符或字符串结果："+sb);
        sb.reverse();   //翻转字符串
        System.out.println("reverse翻转字符串结果："+sb);
    }
}
运行结果
1.添加----------
append添加结果：abcdefg
insert添加结果：ab123cdefg
2.删除----------
delete删除结果：afg
deleatCharAt删除结果：af
delete清空缓冲区结果：
3.修改----------
setCharAt修改指定位置字符结果：apcdef
replace替换指定位置字符或字符串结果：aqqcdef
reverse翻转字符串结果：fedcqqa
注：String类重写了Object类的equals()方法，而StringButter类没有。
要比较StringBuffer的字符串是否相等，需要用toString()转换成String类再进行比较。
String a = new String("abc");
String b = new String("abc");
System.out.println(a.equals(b));   //结果为true
StringBuffer sb1 = new StringBuffer("abc");
StringBuffer sb2 = new StringBuffer("abc");
System.out.println(sb1.equals(sb2));   //结果为false
System类
System类定义了一些与系统相关的属性和方法，它所提供的属性和方法都是静态的。
  • static Properties getProperties()
getProperties()方法用于获取当前系统的全部属性，该方法会返回一个Properties对象。
import java.util.Enumeration;
import java.util.Properties;
public class Test{
    public static void main(String[] args) {
        //获取当前系统属性
        Properties properties = System.getProperties();
        //获取所有系统属性的key，返回Enumeration对象
        Enumeration propertyNames = properties.propertyNames();
        while(propertyNames.hasMoreElements()){
            //获取系统属性的键key
            String key = (String)propertyNames.nextElement();
            //获取当前键对应的值value
            String value = System.getProperty(key);
            System.out.println(key+"--->"+value);
        }
    }
}
  • static long currentTimeMillis()
返回long值，该值表示当前时间与1970年1月1日8点0分0秒之间的时间差，单位毫秒，习惯性的被称作时间戳。
 
public class Test{
    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();    //循环开始的当前时间
        int sum = 0;
        for(int i=0;i<100000;i++){
            for (int j=0;j<=i;j++)
                sum++;
        }
        long endTime = System.currentTimeMillis();  //循环结束的当前时间
        System.out.println("程序运行的时间为："+(endTime-startTime)+"毫秒");
    }
}
运行结果
程序运行的时间为：2440毫秒
  • static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
该方法用于将一个数组中的元素快速拷贝到另一个数组。其中src（源数组），dest（目标数组），srcPos（源数组中拷贝元素的起始位置），destPos（拷贝到目标数组的起始位置），length（拷贝元素的个数）。
public class Test{
    public static void main(String[] args) {
        int[] fromArray = {101,102,103,104,105,106};    //源数组
        int[] toArray = {201,202,203,204,205,206,207};  //目标数组
        System.arraycopy(fromArray,2,toArray,3,4);  //拷贝数组元素
        //打印目标数组中的元素
        for(int i=0;i<toArray.length;i++){
            System.out.println(i+": "+toArray[i]);
        }
    }
}
运行结果
0: 201
1: 202
2: 203
3: 103
4: 104
5: 105
6: 106
除此之外，常用的还有 System.gc(); 垃圾回收，System.exit(int status); 终止当前正在运行的Java虚拟机，status表示状态码，非0表示异常终止。
Runtime类
Runtime类用于表示虚拟机运行时的状态，用于封装JVM虚拟机进程。该类采用的是单例模式设计，对象不可以被实例化，只能通过“Runtime run = Runtime.getRuntime()”方式创建一个Runtime的实例对象。
public class Test{
    public static void main(String[] args) {
        Runtime rt = Runtime.getRuntime();  //获取
        System.out.println("处理器个数： "+rt.availableProcessors()+"个");
        System.out.println("空闲内存数量： "+rt.freeMemory()/1024/1024+"M");
        System.out.println("最大可用内存数量： "+rt.maxMemory()/1024/1024+"M");
    }
}
运行结果
处理器个数： 4个
空闲内存数量： 187M
最大可用内存数量： 3040M
Runtime类提供了exec()方法，用于执行一个dos命令。
public class Test{
    public static void main(String[] args) {
        Runtime rt = Runtime.getRuntime();  //创建Runtime实例对象
        //捕获异常里调用exec()方法打开记事本
        try{rt.exec("notepad.exe");}catch(Exception e){e.printStackTrace();}
    }
}
exec()方法返回一个Process对象，该对象表示操作系统的一个进程，关闭此进程只需调用destroy()方法即可。
以下是打开记事本3秒后自动关闭
public class Test{
    public static void main(String[] args) {
        Runtime rt = Runtime.getRuntime();  //创建Runtime实例对象
        //捕获异常里调用exec()方法打开记事本
        try{
            Process process = rt.exec("notepad.exe");   //得到表示进程的Process对象
            Thread.sleep(3000);     //程序休眠3秒
            process.destroy();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}
Math类
public class Test{
    public static void main(String[] args) {
        System.out.println("计算绝对值: "+Math.abs(-1));
        System.out.println("求大于参数的最小整数: "+Math.ceil(5.4));
        System.out.println("求小于参数的最大整数: "+Math.floor(-5.2));
        System.out.println("对小数四舍五入: "+Math.round(-4.6));
        System.out.println("生成一个最接近参数的整数值: "+Math.rint(10.5));//除了0.5这个值其他的和四舍五入相同
        System.out.println("求两个数的较大值: "+Math.max(1,2.0));
        System.out.println("求两个数的较小值: "+Math.min(1,2.0));
        System.out.println("生成一个大于等于0.0小于1.0随机值: "+Math.random());
        System.out.println("e的值: "+Math.E);
        System.out.println("e的参数次方： "+Math.exp(1.0));
        System.out.println("参数的自然底数的对数值: "+Math.log(Math.E));
        System.out.println("返回第一个参数的第二个参数次方: "+Math.pow(2,3));
        System.out.println("返回参数的算数平方根: "+Math.sqrt(16));
    }
}
运行结果
计算绝对值: 1
求大于参数的最小整数: 6.0
求小于参数的最大整数: -6.0
对小数四舍五入: -5
生成一个最接近参数的整数值: 10.0
求两个数的较大值: 2.0
求两个数的较小值: 1.0
生成一个大于等于0.0小于1.0随机值: 0.1599159306911967
e的值: 2.718281828459045
e的参数次方： 2.718281828459045
参数的自然底数的对数值: 1.0
返回第一个参数的第二个参数次方: 8.0
返回参数的算数平方根: 4.0
Random类
在JDK的java.util包中有一个Random类，它可以在指定的取值范围内随机产生数字。Random类提供了两个构造方法，Random()用于创造一个伪随机数生成器，Random(long seed)使用一个long型的seed种子创建伪随机数生成器。
无参的构造方法每次使用的种子是随机的，所以产生的随机数不同，而有参的构造方法运行多次产生的随机数是相同的。
import java.util.Random;
public class Test{
    public static void main(String[] args) {
        Random r = new Random();
        //随机产生5个[0,100)的随机数
        for(int i=0;i<5;i++){
            System.out.println(r.nextInt(100));
        }
    }
}
第一次运行结果
43
60
88
84
82
第二次运行结果
80
58
59
69
27
 
import java.util.Random;
public class Test{
    public static void main(String[] args) {
        Random r = new Random(1);   //创建对象时传入种子
        //随机产生5个[0,100)的随机数
        for(int i=0;i<5;i++){
            System.out.println(r.nextInt(100));
        }
    }
}
第一次运行结果
85
88
47
13
54
第二次运行结果
85
88
47
13
54
 
Random类的常用方法
 
方法声明
功能描述
boolean nextBoolean()
随机生成boolean类型的随机数
double nextDouble()
随机生成double类型的随机数
float nextFloat()
随机生成float类型的随机数
int nextInt()
随机生成int类型的随机数
int nextInt(int n)
随机生成0~n之间int类型的随机数
long nextLong()
随机生成long类型的随机数
 
包装类
通过包装类可以将基本类型的值包装成引用数据类型的对象。
除了char对应Character，int对应Integer外，其他都是将首字母大写即可。
包装类和基本数据类型转换时，引入了装箱（将基本数据类型的值转为引用数据类型）和拆箱（将引用数据类型的值转为基本数据类型）的概念。
Integer类常用方法
 
方法声明
功能描述
toBinaryString(int i)
以二进制无符号整数形式返回一个整数参数的字符串
toHexString(int i)
以十六进制无符号整数形式返回一个整数参数的字符串
toOctalString(int i)
以八进制无符号整数形式返回一个整数参数的字符串
valueOf(int i)
返回一个表示指定的int值的Integer实例
valueOf(String s)
返回保存指定的String值的Integer对象
parseInt(String s)
将字符串参数作为有符号的十进制整数进行解析
intValue()
将Integer类型的值以int类型返回
 
装箱：
public class Test{
    public static void main(String[] args) {
        int a = 20;
        Integer i = new Integer(a);
        System.out.println(i.toString());
    }
}
运行结果
20
拆箱：
public class Test{
    public static void main(String[] args) {
        Integer i = new Integer(20);
        int a = 10;
        int num = i.intValue()+a;
        System.out.println(num);
    }
}
运行结果
30
 
public class Test{
    public static void main(String[] args) {
        System.out.println("10的二进制表示："+Integer.toBinaryString(10));
        System.out.println("10的八进制表示："+Integer.toOctalString(10));
        System.out.println("10的十六进制表示："+Integer.toHexString(10));
        System.out.println("二进制1010的十进制表示："+Integer.valueOf("1010",2));
        System.out.println("八进制-12的十进制表示："+Integer.valueOf("-12",8));
        System.out.println("十六进制a的十进制表示："+Integer.valueOf("a",16));
        System.out.println("二进制-1010的十进制表示"+Integer.parseInt("-1010",2));
        System.out.println("八进制12的十进制表示："+Integer.parseInt("12",8));
        System.out.println("十六进制-a的十进制表示："+Integer.parseInt("-a",16));
        System.out.println(Integer.valueOf("-15"));
        System.out.println(Integer.parseInt("-15"));
        int a = new Integer(10).intValue(); //Integer实例对象.intValue()
        int b = Integer.valueOf(10).intValue(); //Integer.valueOf(int i)就是表示一个指定int值的Integer实例
        int c = Integer.valueOf("-10").intValue();  //Integer.valueOf(String s)就是表示一个指定String值的Integer实例
        System.out.println("a:"+a+" b:"+b+" c:"+c);
    }
}
运行结果
10的二进制表示：1010
10的八进制表示：12
10的十六进制表示：a
二进制1010的十进制表示：10
八进制-12的十进制表示：-10
十六进制a的十进制表示：10
二进制-1010的十进制表示-10
八进制12的十进制表示：10
十六进制-a的十进制表示：-10
-15
-15
a:10 b:10 c:-10
注：①包装类都重写了toString()方法，以字符串形式返回②除了Character外，包装类都有valueOf(String s)方法，字符串s不能为null而且必须能解析成相应的基本数据类型，可以根据String类型的参数创建包装类对象：
Integer i = Integer.valueOf(“123”);
③除了Character外，包装类都有parseXXX(String s)的静态方法，字符串s不能为null而且必须能解析成相应的基本数据类型，将字符串转换为对应基本类型数据：
int i = Integer.parseInt(“123”);
三种日期类Date类、Calendar类与DateFormat类
Date类中无参的构造方法Date()用来创建当前时间的Date对象，接收long型参数的构造方法Date(long date)，date参数表示1970.01.01 08:00:00(称为历元)以来的毫秒数。
import java.util.Date;
public class Test{
    public static void main(String[] args) {
        Date date1 = new Date();
        Date date2 = new Date(100000L);
        Date date3 = new Date(System.currentTimeMillis());
        System.out.println(date1);
        System.out.println(date2);
        System.out.println(date3);
    }
}
运行结果
Sat Oct 05 14:26:24 CST 2019
Thu Jan 01 08:01:40 CST 1970
Sat Oct 05 14:26:24 CST 2019
Calendar类可以设置和读取日期特定部分，是抽象类，不能被实例化，需要调用其静态方法getInstance()来得到一个Calendar对象。
Calendar的常用方法
 
方法声明
功能描述
int get(int field)
返回指定日历字段的值
void add(int field,int amount)
根据日历规则，为指定的日历字段增加或减去指定的时间量
void set(int field,int value)
为指定日历字段设置指定值
void set(int year,int month,int date)
设置Calendar对象的年月日三个字段的值
void set(int year,int,mouth,int date,int hourOfDate,int minute,int second)
设置Calendar对象的年月日时分秒六个字段的值
 
上面field参数需要接收Calendar类中定义的常量值，要注意的是Calendar.MONTH字段月份是从0开始的不是1。
import java.util.Calendar;
public class Test{
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();//获取表示当前时间的Calendar对象
        int year = calendar.get(Calendar.YEAR); //获取当前年
        int month = calendar.get(Calendar.MONTH)+1; //获取当前月
        int date = calendar.get(Calendar.DATE); //获取当前日
        int hour = calendar.get(Calendar.HOUR); //获取当前时
        int minute = calendar.get(Calendar.MINUTE); //获取当前分
        int second = calendar.get(Calendar.SECOND); //获取当前秒
        System.out.println("当前时间： "+calendar.getTime());    //getTime()获取时间
        System.out.println("当前时间： "+year+"年"+month+"月"+date+"日"+hour+"时"+minute+"分"+second+"秒");
    }
}
运行结果
当前时间： Sat Oct 05 15:29:37 CST 2019
当前时间： 2019年10月5日3时29分37秒
 
import java.util.Calendar;
public class Test{
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(2019,10,1);//  修改z时间为2019.10.01
        calendar.add(Calendar.DATE,100);    //日  加100天
        System.out.println("2019.10.01的100天后是"+calendar.get(Calendar.YEAR)+"."+calendar.get(Calendar.MONTH+1)+"."+calendar.get(Calendar.DATE));
    }
}
运行结果
2019.10.01的100天后是2020.7.9
Calendar有两种解释：日历字段的模式--lenient模式（默认模式）和non-lenient模式。Calendar.MONTH取值是0~11，当超过数值时比如13，会设置为“一年两个月”，当改为non-lenient模式时，会抛出异常
import java.util.Calendar;
public class Test{
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();//当前时间为2019.10.5
        //将MONTH字段设置为13
        calendar.set(Calendar.MONTH,13);
        System.out.println(calendar.getTime());
        //开启non-lenient模式
        calendar.setLenient(false);
        calendar.set(Calendar.MONTH,13);
        System.out.println(calendar.getTime());
    }
}
运行结果
Wed Feb 05 15:46:15 CST 2020
Exception in thread "main" java.lang.IllegalArgumentException: MONTH
Calendar的getTime()方法返回一个表示Calendar时间值的Date对象，
Calendar的setTime(Date date)方法接收一个Date对象，
通过这两个方法就可以完成Date和Calendar对象的转换。
Calendar.getInstance().setTime(new Date());
DateFormat类是抽象类，不能被直接实例化，可以用它的四个静态方法获取，它们可以分别对日期或者时间部分进行格式化。
FULL常量表示完整格式，LONG常量表示长格式，MEDIUM常量表示普通格式，SHORT常量表示短格式。
import java.text.DateFormat;
import java.util.Date;
public class Test{
    public static void main(String[] args) {
        Date date = new Date();
        //FULL格式的日期格式器对象
        DateFormat fullFormat = DateFormat.getDateInstance(DateFormat.FULL);
        System.out.println("FULL格式："+fullFormat.format(date));
        DateFormat fullFormat1 = DateFormat.getDateTimeInstance(DateFormat.FULL,DateFormat.FULL);
        System.out.println("FULL格式："+fullFormat1.format(date));
        //LONG格式的日期格式器对象
        DateFormat longFormat = DateFormat.getDateInstance(DateFormat.LONG);
        System.out.println("LONG格式："+longFormat.format(date));
        DateFormat longFormat1 = DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);
        System.out.println("LONG格式："+longFormat1.format(date));
        //MEDIUM格式的日期格式器对象
        DateFormat mediumFormat = DateFormat.getDateInstance(DateFormat.MEDIUM);
        System.out.println("MEDIUM格式："+mediumFormat.format(date));
        DateFormat mediumFormat1 = DateFormat.getDateTimeInstance(DateFormat.MEDIUM,DateFormat.MEDIUM);
        System.out.println("MEDIUM格式："+mediumFormat1.format(date));
        //SHORT格式的日期格式器对象
        DateFormat shortFormat = DateFormat.getDateInstance(DateFormat.SHORT);
        System.out.println("SHORT格式："+shortFormat.format(date));
        DateFormat shortFormat1 = DateFormat.getDateTimeInstance(DateFormat.SHORT,DateFormat.SHORT);
        System.out.println("SHORT格式："+shortFormat1.format(date));
    }
}
运行结果
FULL格式：2019年10月5日星期六
FULL格式：2019年10月5日星期六 中国标准时间 下午4:37:51
LONG格式：2019年10月5日
LONG格式：2019年10月5日 CST 下午4:37:51
MEDIUM格式：2019年10月5日
MEDIUM格式：2019年10月5日 下午4:37:51
SHORT格式：2019/10/5
SHORT格式：2019/10/5 下午4:37
getDateInstance()方法获得的实例对象用于对日期部分进行格式化，
getDateTimeInstance()方法获得的实例对象用于对日期和时间进行格式化。
DateFormat类还提供了parse(String source)方法，将字符串解析成Date对象，该方法需要捕获异常。
import java.text.DateFormat;
public class Test{
    public static void main(String[] args) {
        //创建LONG格式的DateFormat对象
        DateFormat df = DateFormat.getDateInstance(DateFormat.LONG);
        String d = "2000年10月1日";
        try{
            System.out.println(df.parse(d));    //字符串解析
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
运行结果
Sun Oct 01 00:00:00 CST 2000
SimpleDateFormat类是DateFormat的子类，可以使用new关键字创建实例对象，它的构造方法接收一个格式字符串参数，表示日期格式模板。
import java.text.SimpleDateFormat;
import java.util.Date;
public class Test{
    public static void main(String[] args) {
        SimpleDateFormat sdf = new SimpleDateFormat("Gyyyy年MM月dd日E,第D天");
        System.out.println(sdf.format(new Date()));
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy/MMM/dd");
        String dt = "2009/五月/03";
        try{
            System.out.println(sdf1.parse(dt));    //字符串解析
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
运行结果
公元2019年10月05日周六,第278天
Sun May 03 00:00:00 CST 2009
 
 

Java学习笔记5（API）的更多相关文章

  1. Java学习笔记之---API的应用

    Java学习笔记之---API的应用 (一)Object类 java.lang.Object 类 Object 是类层次结构的根类.每个类都使用 Object 作为超类.所有对象(包括数组)都实现这个 ...

  2. Java学习笔记--反射API

    反射API 1.反射API的介绍 通过反射API可以获取Java程序在运行时刻的内部结构.比如Java类中包含的构造方法.域和方法等元素,并可以与这些元素进行交换.     按照 一般地面向对象的设计 ...

  3. Java学习笔记二--API课堂记录

    JavaSE课堂记录(二) 第一节课 方法的重载:方法名相同,参数列表不同 方法的重写:方法名,参数列表相同 两同:方法名相同,参数列表相同 两小:访问权限小与等于父类,返回值类型小于等于父类(返回值 ...

  4. 0035 Java学习笔记-注解

    什么是注解 注解可以看作类的第6大要素(成员变量.构造器.方法.代码块.内部类) 注解有点像修饰符,可以修饰一些程序要素:类.接口.变量.方法.局部变量等等 注解要和对应的配套工具(APT:Annot ...

  5. 0030 Java学习笔记-面向对象-垃圾回收、(强、软、弱、虚)引用

    垃圾回收特点 垃圾:程序运行过程中,会为对象.数组等分配内存,运行过程中或结束后,这些对象可能就没用了,没有变量再指向它们,这时候,它们就成了垃圾,等着垃圾回收程序的回收再利用 Java的垃圾回收机制 ...

  6. 《Java学习笔记(第8版)》学习指导

    <Java学习笔记(第8版)>学习指导 目录 图书简况 学习指导 第一章 Java平台概论 第二章 从JDK到IDE 第三章 基础语法 第四章 认识对象 第五章 对象封装 第六章 继承与多 ...

  7. 20145330第十周《Java学习笔记》

    20145330第十周<Java学习笔记> 网络编程 网络编程就是在两个或两个以上的设备(例如计算机)之间传输数据.程序员所作的事情就是把数据发送到指定的位置,或者接收到指定的数据,这个就 ...

  8. 20145330第九周《Java学习笔记》

    20145330第九周<Java学习笔记> 第十六章 整合数据库 JDBC入门 数据库本身是个独立运行的应用程序 撰写应用程序是利用通信协议对数据库进行指令交换,以进行数据的增删查找 JD ...

  9. 20145330第八周《Java学习笔记》

    20145330第八周<Java学习笔记> 第十五章 通用API 通用API 日志:日志对信息安全意义重大,审计.取证.入侵检验等都会用到日志信息 日志API Logger:注意无法使用构 ...

  10. 20145330第七周《Java学习笔记》

    20145330第七周<Java学习笔记> 第十三章 时间与日期 认识时间与日期 时间的度量 GMT(格林威治标准时间):现在不是标准时间 世界时(UT):1972年UTC出来之前,UT等 ...

随机推荐

  1. StreamSets使用指南

    StreamSets使用指南 最近在调研Streamsets,照猫画虎做了几个最简单的Demo鉴于网络上相关资料非常少,做个记录. 1.简介 Streamsets是一款大数据实时采集和ETL工具,可以 ...

  2. 《机器学习Python实现_09_02_决策树_CART》

    简介 CART树即分类回归树(classification and regression tree),顾名思义,它即能用作分类任务又能用作回归任务,它的应用比较广泛,通常会用作集成学习的基分类器,总得 ...

  3. 五、Java - 集合

    一.集合 Java 中的集合类存放于 java.util 包中,是一个存放对象的容器. 集合存放的是对对象的引用,对象本身还是存在于 JVM 堆内存中. 存放的是对象,即引用数据类型,对于基本数据类型 ...

  4. Spring Cloud Stream微服务消息框架

    简介 随着近些年微服务在国内的盛行,消息驱动被提到的越来越多.主要原因是系统被拆分成多个模块后,一个业务往往需要在多个服务间相互调用,不管是采用HTTP还是RPC都是同步的,不可避免快等慢的情况发生, ...

  5. winxp无法访问win10教育版共享资源的问题处理

    一.问题来源: dell5460笔记本上一个winxp系统虚拟机,访问一台lenovoT470笔记本win10教育版系统上的共享资源(使用命令行方式:net use s: \\172.18.45.10 ...

  6. Vue中导出Excel表格方法

    本文记录一下在Vue中实现导出Excel表格的做法.参考度娘上各篇博客,最后实现功能 Excel表格,我的后端返回的是数据流,然后文件名是放进了content-disposition中,前端进行获取. ...

  7. （Java实现） 洛谷 P1012 拼数

    题目描述 设有nn个正整数(n≤20)(n≤20),将它们联接成一排,组成一个最大的多位整数. 例如:n=3n=3时,3个整数13,312,343联接成的最大整数为:3433121334331213 ...

  8. C# winform 学习（一）

    目标 1.类和对象 2.定义类 3.对象的操作 4.命名空间 一.类和对象 1.理解 1)类:具有共同特征和行为的一类事物的统称 2)对象:类的一个具体唯一的实例 eg: 1路公交车;(类) 车牌为F ...

  9. Java实现 蓝桥杯 算法提高 三角形

    算法提高 12-1三角形 时间限制:1.0s 内存限制:256.0MB 提交此题 问题描述 为二维空间中的点设计一个结构体,在此基础上为三角形设计一个结构体.分别设计独立的函数计算三角形的周长.面积. ...

  10. Java实现 泊松分酒

    泊松是法国数学家.物理学家和力学家.他一生致力科学事业,成果颇多.有许多著名的公式定理以他的名字命名,比如概率论中著名的泊松分布. 有一次闲暇时,他提出过一个有趣的问题,后称为:"泊松分酒& ...