System

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//out对象，标准输出对象
System.out.println("hello");

//in对象，标椎输入对象
Scanner sc = new Scanner(System.in);

//err:用来输出错误信息
//System.err.println("world");

//方法
//currentTimeMillis():返回的是从1970-1-1 0:0:0.0 到此时此刻的毫秒数
long time = System.currentTimeMillis();
System.out.println(time);

//exit():退出程序，0：正常退出，非0不正常退出
System.exit(0);
System.out.println("程序结束了");

String

String介绍

  1. class final String 是一个最终类，不能被继承

  2. final char value[]:用于存储字符串中的每个字符

  3. 字符串是一个不可变的
    常量池中不会将相同的数据保存多份的

    常量池中的字符串数据也是不可变的

  4. 通过字面量形式定义的字符串变量，变量里面保存的是字符串数据在常量池中的地址
    通过new形式创建的字符串变量，变量保存的是在堆区创建的String对象地址，对象中value属性指向字符串数据在常量池中的地址

常用API

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 int length() !!
  char charAt(int index) !!
  boolean isEmpty()
  String toLowerCase()
  String toUpperCase()
  String trim()
  boolean equals(Object obj) !!
  boolean equalsIgnoreCase(String anotherString)
  String concat(String str)
  int compareTo(String anotherString)
  String substring(int beginIndex) !!
  String substring(int beginIndex, int endIndex)

  boolean endsWith(String suffix) ：判断字符串是否已什么结尾

boolean startsWith(String prefix)：判断字符串是否已什么开头
boolean contains(CharSequence s)：是否包含什么   !!

  int indexOf(String str) ：获取指定str在字符串中的起始下标  !!

  String replace(CharSequence target, CharSequence replacement)
  String replaceAll(String regex, String replacement)

  String[] split(String regex)：按照指定的regex进行字符串分割，进分割后的子串以字符串数组返回  !!

字符串和数组之间的相互转换

1
2
3
4
5
6
7
8
9
10
11
12
13
@Test
public void t3() throws UnsupportedEncodingException {
	String str = "I love 中国";
	// 将字符串照指定编码转换成字节数组
	// utf8:三个字节表示一个汉字，bgk：两个字节表示一个汉字
	byte[] bytes = str.getBytes("utf8"); // 参数代表编码格式：utf8 gbk
	for (byte b : bytes) {
		System.out.println(b);
	}
			
	String str1 = new String(bytes, "utf8"); // 将字节数组按照指定编码转换成字符串
	System.out.println(str1);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Test
public void t2() {
	String str = "I love 中国";
	// 字符串转换成字节数组
	// 编码：人看懂 ---> 电脑看得懂（二进制）
	byte[] bytes = str.getBytes(); // 当前环境默认的编码格式
	for (byte b : bytes) {
		System.out.println(b);
	}
	
	// 将字节数组转换成字符串
	// 解码： 电脑看得懂（二进制）---> 人看懂 
	String str1 = new String(bytes);
	System.out.println(str1);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Test 
public void t1() {
	String str = "I love 中国";
	
	// 字符串转换成字符数组
	char[] array = str.toCharArray();
	for (char c : array) {
		System.out.println(c);
	}
	
	// 将字符数组转换成字符串
	String str1 = new String(array);
	System.out.println(str1);
}

StringBuffer

String因为是不可变的，有的时候会带来一些性能问题

StringBuffer & StringBuilder是可变的，就是说可以在原有基础上进行更改，不用频繁创建字符串对象

  • 涉及到字符串高频次的操作时，建议使用StringBuffer & StringBuilder
    • StringBuilder：效率更高，但是不是线程安全的
    • StringBuffer：效率会低一点，但是是线程安全的

日期类

Date

Date:日期

可以获取相关日期信息，年月日时分秒

1
2
3
4
5
Date date = new Date();

System.out.println(date.getTime());// 获取1970-1-1 0：0:0.0毫秒数

System.out.println(date);

SimpleDateFormat

日期格式化类 format：可以将date对象转成指定格式的字符串 parse：将字符串再转回成date对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
SimpleDateFormat sdf = new SimpleDateFormat();
String time = sdf.format(new Date());
System.out.println(time);

// 2019-2-29 2019/9/29 16:16:50
// y:年 、 M：月、 d：日 、 h:时 、 m：分 、 s：秒 、 E:星期
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss E"); // 指定格式
String time2 = sdf2.format(new Date());
System.out.println(time2);

// 将字符串再转回成date对象
// Date date = sdf2.parse(time2);
Date date = sdf2.parse("2019-09-29 16:16:16 星期日");// 字符串的格式要和SimpleDateFormat里面指定的格式一致
System.out.println(date);

Calendar

Calendar：日历类

1
2
3
4
5
6
7
8
9
10
11
12
13
// 通过静态方法getInstance()获取对象
Calendar calendar = Calendar.getInstance();

System.out.println(calendar.get(Calendar.YEAR)); // 年
System.out.println(calendar.get(Calendar.MONTH)); // 月份从0开始
System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
System.out.println(calendar.get(Calendar.HOUR)); // 12小时制
System.out.println(calendar.get(Calendar.HOUR_OF_DAY)); // 24小时制
System.out.println(calendar.get(Calendar.MINUTE)); // 分
System.out.println(calendar.get(Calendar.SECOND)); // 秒

Date time = calendar.getTime(); // 获取Date对象
System.out.println(time);

算数类

Math

Math:数学类，提供了很多数学相关的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
System.out.println(Math.PI); // 圆周率
		
System.out.println(Math.abs(-12)); // 取绝对值

System.out.println(Math.ceil(12.1)); // 向上取整
System.out.println(Math.floor(12.6)); // 向下取整
System.out.println(Math.round(12.5)); // 四舍五入

System.out.println(Math.pow(2, 3)); // 求参数1的参数2次幂
System.out.println(Math.sqrt(4)); // 求平方根

System.out.println(Math.sin(Math.PI/6)); // 三角函数

System.out.println(Math.max(2, 5)); // 取最大值
System.out.println(Math.min(2, 5)); // 取最小值

Random

Random:随机数类

1
2
3
4
Random random = new Random();
		
System.out.println(random.nextInt()); // 随机整数
System.out.println(random.nextInt(10)); // 获取0 -10 之间的随机数，但不包括10

超级数字

BigInteger

1
2
3
4
5
6
7
8
// BigInteger可以表示一个超大的整数
BigInteger bint1 = new BigInteger("10000000000000000000");
BigInteger bint2 = new BigInteger("20000000000000000000");

BigInteger data1 = bint1.add(bint2); // +
BigInteger data2 = bint1.subtract(bint2); // -
BigInteger data3 = bint1.multiply(bint2); // *
BigInteger data4 = bint1.divide(bint2);  // 除法

BigDecimal

1
2
3
4
5
6
7
8
9
// BigDecimal:表示超级小数，并且还能精确显示
// 推荐将小数以字符串的形式传入
BigDecimal x = new BigDecimal("0.1");
BigDecimal y = new BigDecimal("0.2");

BigDecimal data = x.add(y);
BigDecimal data2 = x.subtract(y);
BigDecimal data3 = x.multiply(y);
BigDecimal data4 = x.divide(y);

Arrays

1
2
3
4
5
6
7
8
9
10
11
12
int[] data = {52,96,85,45,86,25};
String[] data2 = {"dfg","sfg","gre","sdfgr"};
Arrays.sort(data); // 自然排序（从小到大）	
for(int i : data) {
  System.out.println(i);
}

// toString():可以将数组中的所有元素拼接成一个字符串返回
String str1 = Arrays.toString(data);

//数组拷贝：参数1：要拷贝的目标数组，参数2新数组的长度
int[] copy = Arrays.copyOf(data, 10);

Comparable

排序的对象必须实现Comparable接口

内部调用了重写的compareTo方法进行对象间的比较

1
2
3
4
5
6
7
8
9
10
11
public class Goods implements Comparable<Goods> {
	/*
	 *  返回值 < 0：当前对象 < 传入的对象
	 *  返回 = 0：当前对象 = 传入的对象
	 *  返回值 > 0：当前对象 > 传入的对象
	 */
	@Override
	public int compareTo(Goods goods) {
		return price - goods.price;
	}
}
1
2
3
4
5
6
7
8
9
10
// 当类实现的Comparable接口指定的比较规则不适用当前情况时，
// 可以在sort方法中传入Comparator对象，设定当前适合的比较规则
// Comparator可以灵活的设定其他比较的规则，这样就不会按照类中默认的比较规则比大小了
Arrays.sort(goods, new Comparator<Goods>() {
  @Override
  public int compare(Goods o1, Goods o2) {
    // 这里就是按照销量来比大小了
    return o1.xiaoLiang - o2.xiaoLiang;
  }
});