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. window端口被占用

    一.问题描述 今天一来公司,在IntelliJ IDEA 中启动Tomcat服务器时就出现了如下图所示的错误: 错误: 代理抛出异常错误: java.rmi.server.ExportExceptio ...

  2. Java IO（八） PipedInputStream 和 PipedOutputStream

    Java IO(八) PipedInputStream 和 PipedOutputStream 一.介绍 PipedInputStream 和 PipedOutputStream 是管道输入流和管道输 ...

  3. PAT 1033 To Fill or Not to Fill (25分) 贪心思想

    题目 With highways available, driving a car from Hangzhou to any other city is easy. But since the tan ...

  4. 从汉堡加料说起——浅谈C#中的Decorator模式

    相信大家都在都在汉堡店吃过汉堡,有些汉堡店很有特色,推出了汉堡订制服务,即,可以在汉堡中加料,加肉饼,加生菜之类(有点类似我们本地的肥肠粉里面加冒结子).更是让不少吃货大快朵颐,大呼过瘾,加6,7层肉 ...

  5. Rocket - debug - TLDebugModuleInner - DMI Register Control and Status

    https://mp.weixin.qq.com/s/tI41wu0xaIQ5PRq6F82tNw 简单介绍TLDebugModuleInner中生成DMI控制和状态寄存器使用到的状态. 1. abs ...

  6. JAVASE(十四) 集合： 数组和集合、Collection、Iterator、List、Set、Map

    个人博客网:https://wushaopei.github.io/    (你想要这里多有) 1.数组和集合 1.1 内存中对数据进行存储和管理的“容器”:数组,集合 1.2 数组存储的特点和缺点 ...

  7. JavaScript (四) js的基本语法 - - 函数练习、arguments、函数定义、作用域、预解析

    个人博客网:https://wushaopei.github.io/    (你想要这里多有) 一.函数练习 1.求最值 // - 求2个数中的最大值 function getMax(num1, nu ...

  8. Java实现 蓝桥杯 算法训练 K好数

    算法训练 K好数 时间限制:1.0s 内存限制:256.0MB 提交此题 锦囊1 锦囊2 问题描述 如果一个自然数N的K进制表示中任意的相邻的两位都不是相邻的数字,那么我们就说这个数是K好数.求L位K ...

  9. Java实现 LeetCode 114 二叉树展开为链表

    114. 二叉树展开为链表 给定一个二叉树,原地将它展开为链表. 例如,给定二叉树 1 / \ 2 5 / \ \ 3 4 6 将其展开为: 1 \ 2 \ 3 \ 4 \ 5 \ 6 class S ...

  10. ASP.NET Core Blazor Webassembly 之 路由

    web最精妙的设计就是通过url把多个页面串联起来,并且可以互相跳转.我们开发系统的时候总是需要使用路由来实现页面间的跳转.传统的web开发主要是使用a标签或者是服务端redirect来跳转.那今天来 ...