Scanner
package you.demo.scanner; import java.util.Scanner; public class ScannerDemo { /* * JDK1.5的时候诞生的， * Scanner: 获取 键盘输入的数据的 封装类 * Scanner sc = new Scanner(System.in); * * 需要掌握的方法： * String: 获取字符串数据 * public String nextLine() * int: 获取int数据 * public int nextInt() * * String -- String 可以 * String -- int 可以 * int -- int 可以 * int -- String 不可以 * 如果必须要先获取int，再获取String ，那么可以创建多个Scanner对象来完成操作 */ public static void main(String[] args) { // // TODO Auto-generated method stub // //创建获取键盘输入数据的对象 Scanner sc = new Scanner(System.in);//System.in 标准输入流 //获取字符串 String str = sc.nextLine(); //输出,我们运行后，控制台console什么也没有输出，此时我们在控制台输入参数，回车，既能看到效果 System.out.println(str); //获取int数据 注意此时虽然我们上面已经有了获取字符串操作，但当我们有获取数据操作时，输入字符串仍然会报异常，通下面异常，类型不匹配 int number = sc.nextInt(); System.out.println(number); //如果我们在方法中只保留获取字符串的方法，输入数据是可以的，但是如果只保留i获取int方法，输入字符串是不行的,会报java.util.InputMismatchException输入类型不匹配 // int num = sc.nextInt(); // System.out.println(num); } }
String
在Java中字符串作为String类的实例来处理。以对象的方式处理字符串，将使字符串更加灵活、方便。可以通过java.lang包中的string类来创建字符串对象。
从上面的两幅图中我们可以看到，
字符串声明当我们new String("abc");会现在堆中创建一个字符串对象，然后会在常量池中寻找是否有一个字符串常量abc,如果有则把这个字符串常量在堆中赋值一份，注意此时堆中又有了一个引用了（复制的字符串常量引用），所以上面这种声明字符串会在堆中创建两个对象。【
答案也是众所周知的，2个。
我们可以把上面这行代码分成String str、=、”123″和new String()四部分来看待。String str只是定义了一个名为str的String类型的变量，因此它并没有创建对象；=是对变量str进行初始化，将某个对象的引用（或者叫句柄）赋值给它，显然也没有创建对象；现在只剩下new String(“123″)了。那么，new String(“123″)为什么又能被看成”123″和new String()呢？
我们来看一下被我们调用了的String的构造器：
public String(String original) { //other code … } 大家都知道，我们常用的创建一个类的实例（对象）的方法有以下两种:
一、使用new创建对象。
二、调用Class类的newInstance方法，利用反射机制创建对象。
我们正是使用new调用了String类的上面那个构造器方法创建了一个对象，并将它的引用赋值给了str变量。同时我们注意到，被调用的构造器方法接受的参数也是一个String对象，这个对象正是”123″。由此我们又要引入另外一种创建String对象的方式的讨论——引号内包含文本。
这种方式是String特有的，并且它与new的方式存在很大区别。
String str=”123″;
毫无疑问，这行代码创建了一个String对象。
String a=”123″; String b=”123″; 那这里呢？
答案还是一个。
String a=”123″+”456″; 再看看这里呢？
答案是三个。
说到这里，我们就需要引入对字符串池相关知识的回顾了。
在JAVA虚拟机（JVM）中存在着一个字符串池，其中保存着很多String对象，并且可以被共享使用，因此它提高了效率。由于String类是final的，它的值一经创建就不可改变，因此我们不用担心String对象共享而带来程序的混乱。字符串池由String类维护，我们可以调用intern()方法来访问字符串池。
我们再回头看看String a=”123″;，这行代码被执行的时候，JAVA虚拟机首先在字符串池中查找是否已经存在了值为”123″的这么一个对象，它的判断依据是String类equals(Object obj)方法的返回值。如果有，则不再创建新的对象，直接返回已存在对象的引用；如果没有，则先创建这个对象，然后把它加入到字符串池中，再将它的引用返回。因此，我们不难理解前面三个例子中头两个例子为什么是这个答案了。
只有使用引号包含文本的方式创建的String对象之间使用“+”连接产生的新对象才会被加入字符串池中。对于所有包含new方式新建对象（包括null）的“+”连接表达式，它所产生的新对象都不会被加入字符串池中，对此我们不再赘述。因此我们提倡大家用引号包含文本的方式来创建String对象以提高效率，实际上这也是我们在编程中常采用的。
栈（stack）：主要保存基本类型（或者叫内置类型）（char、byte、short、int、long、float、double、boolean）和对象的引用，数据可以共享，速度仅次于寄存器（register），快于堆。
堆（heap）：用于存储对象】
从第二幅图中我们大致明白了String为什么是已经初始化不可改变，而StringBuffer可以改变，String已经初始化，那么初始化后的字符串常量就存放在字符串常量池中，我们再次对String引用进行赋值，那么只是把另一个字符串引用传给了他，以前的那个引用还在，没有改变，而StringBuffer则不然，StringBuffer会在原有基础上进行改变，改变后产生的是新的字符串，老字符串不存在。
String类
声明字符串
/*声明字符串，在Java语言中字符串必须包含在一对双引号“”之内，如"我是中国人" "you 是 外国人" "1我3"等 * 字符串常量是系统能够显示的任何文字信息，甚至是单个字符，在Java中由双引号“”引起来的都是字符串，不能作为其他数据类型来使用，如“1+3”的输出结果不可能是3，应该是字符串“1+3” * 声明字符串必须经过初始化才能使用，否则编译器会报出“变量未被初始化错误”，当然，如果只是声明了字符串，但不使用它，那么未初始化是可以的 * 声明字符串变量格式：String name = [null];String:指定该变量为字符串类型，name：任何有效的标识符，表示字符串变量名称，null：此处可以是字符串值，也可以是什么也不写，表示字符串的值为null，注意”“和null是不同的 */ public static void statementString(){ //声明字符串 String str1 =""; String str2; String str3; String str4 = null; System.out.println("字符串必须经过初始化才能被使用"+str1); //字符串未被初始化是不可以被使用，包括equals,== //System.out.println(""+str2.equals(str3)); //声明字符串，并为字符串初始化，那么会在堆中创建一个字符串对象，字符串的值存放在常量池中，常量池在方法区 System.out.println("equals比较的是内容"+str1.equals(str4)); System.out.println("==判断的是内容和地址引用"+(str1==str4)); }
创建字符串
/*创建字符串：在Java语言中将字符串作为对象来管理，因此可以像创建其他类对象一样来创建字符串对象，创建对象要使用到string的构造函数，String常用的构造函数如下： * String(char a[]) 用一个字符串数组a创建string对象 * String(char a[],int offset,int length) 提取字符串a中的一部分创建一个字符串对象，参数offset表示开始截取的字符串位置，length表示截取字符串的长度 * String(char[] value) 该构造方法可分配一个新的String对象，使其表示字符数组参数中所有元素连接的结果 * 除了通过以上几种使用String类的构造方法来创建字符串变量外，还可通过字符串常量的引用赋值给一个字符串变量如：String str1; str1="911";等同于String str1 = "911"; * 以上只是通过char类型做的例子，实际还可以有byte类型 */ public static void foundString(){ char a[] = {'s','t','u','d','e','n','t'}; String str1 = new String(a); //等价于String str1 = new String("student"); System.out.println(str1); // String(char a[],int offset,int length) length + offset <= String.length(),否则编译器报出角标越界异常 String str2 = new String(a,3,3); //等价于String str1 = new String("den"); System.out.println(str2); String str3 = new String(a); //等价于String str1 = new String("student"); System.out.println(str3); String str4,str5; str4 = "student"; str5 = "student"; System.out.println(str4+"、"+str5); }
连接字符串
连接多个字符串 连接其他数据类型 将指定字符串连接到此字符串结尾
/*连接字符串：对于已经声明的字符串，可以对其进行相应的操作，链接自负出纳就是其中比较简单的一种，可以对多个字符串进行连接，也可使字符串与其他数据类型进行连接 * 连接多个字符串：使用“+”运算符实现连接多个字符串的功能，“+”运算符可以连接多个运算符并产生一个String对象。一句相连的字符串不能分开在两行写，是错误的，可以通过运算符“+”实现 * 连接其他数据类型：将字符串同其他数据类型进行连接，会将这些数据直接转换成字符串，实际上其他数据类型与字符串相连会首先调用toString()方法将其转换成字符串，然后参数连接 */ public static void connectString(){ int a = 78; byte b = 32; boolean boo = false; String str1 = "字符串连接："; String str2 = str1+a+boo; System.out.println(str2); //如果存在多行字符连接应该是下面这种格式，注意不能省略“+” System.out.println("I like" + "java"); }
String类的判断功能
/*String类的判断功能 * == 运算符判断内容和引用地址 equals(Object anObject) 将此字符串与指定的对象比较。 仅比较内容，区分大小写 equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写。 startsWith(String prefix) 测试此字符串是否以指定的前缀开始。 startsWith(String prefix, int toffset) 测试此字符串从指定索引开始的子字符串是否以指定前缀开始。 endsWith(String suffix) 测试此字符串是否以指定的后缀结束。 contains(CharSequence s) 当且仅当此字符串包含指定的 char 值序列时，返回 true。 isEmpty() 当且仅当 length() 为 0 时返回 true。 matches(String regex) 告知此字符串是否匹配给定的正则表达式。 练习：模拟登录,给三次机会,并提示还有几次. */ public static void judjeString(){ String str1 = new String("string"); String str2 = new String("string"); String str3 = new String(); String str4 = new String(); str3 = "String"; str4 = "String"; //str1和str2在内存中各自创建了两个对象，一个是string类的引用对象，另外new String()会重新申请一块区域把字符串内容复制过来，str1指向string的引用对象 //而str3 = “String”；这种赋值方式会改变指针指向，str3和str4指向的都是内存中存放“String”的区域 System.out.println("str1和str2是两个对象内容相同，但不是同一个对象："+str1.equals(str2)); System.out.println("str1和str2是两个对象内容相同，但不是同一个对象："+(str1==str2)); System.out.println("str1和str3是两个对象内容忽略大小写相同，但不是同一个对象："+str1.equals(str3)); System.out.println("str1和str3是两个对象内容忽略大小写相同，但不是同一个对象："+str1.equalsIgnoreCase(str3)); System.out.println("str3和str4是两个内容相同，指针指向也相同的对象："+str3.equals(str4)); System.out.println("str3和str4是两个内容相同，指针指向也相同的对象："+(str3==str4)); //判断是否以指定前缀开始，判断指定脚标是否以指定字符串开始，区分大小写,注意：脚标判断，脚标越界的话返回false，但编译不会报错 str3 = "tr"; System.out.println("判断str1是否以S开头："+str1.startsWith("S")); System.out.println("判断str1是否以st开头："+str1.startsWith("st")); System.out.println("判断str1脚标1是否以tr开头"+str1.startsWith(str3, 1)); System.out.println("判断str1脚标7是否以t开头（脚标越界，编译照常运行,返回false）："+str1.startsWith("s", 7)); //判断字符串是否以指定字符串结尾 区分大小写 System.out.println("判断str1是否以ing结尾："+str1.endsWith("ing")); System.out.println("判断str1是否以ing结尾："+str1.endsWith("Ing")); //判断字符串是否包含指定的字符串 System.out.println("判断str1是否包含字符in："+str1.contains("in")); //判断字符串中是否有内容，当字符串长度为0是返回true,注意当把字符串对象赋值为null，然后判断会报出空指针异常 //str3 = null; 空指针异常 str3 = ""; System.out.println("判断str1是否为空字符串："+str1.isEmpty()); System.out.println("判断str3是否为空字符串："+str3.isEmpty()); }
登录小代码
public static void loginMethod(){ for (int i = 0; i < 2; i++) { //已知的用户名和密码，用于对比校验 String username = "admin"; String password = "admin"; //声明一个Scanner类，获取键盘输入 Scanner sc = new Scanner(System.in); System.out.println("请输入用户名："); String inputUsername = sc.nextLine(); System.out.println("请输入用户密码："); String inputPassword = sc.nextLine(); //判断已知的信息与输入信息是否一致 if(username.equals(inputUsername) && password.equals(inputPassword)){ System.out.println("恭喜你登陆成功！"); }else { if(i==1){ System.out.println("请检查您的用户名和密码，重新登录！"); }else{ System.out.println("重新登录！"); } } } }
String类的获取功能
/*String类的获取功能 * length() 返回此字符串的长度。 charAt(int index) 返回指定索引处的 char 值。 indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。 int indexOf(int ch, int fromIndex) 返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。 int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引。 int indexOf(String str, int fromIndex) 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。 substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。 String substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。 遍历字符串的每一个字符 */ public static void obtainString(){ String str = "youjob@yeah.net"; //字符串长度 System.out.println("字符串的长度：字符串实际上是字符数组："+str.length()); //返回指定指引处的字符，可以用来遍历字符串 System.out.println("字符串脚标3的字符："+str.charAt(3)); //遍历字符串 for(int i=0;i<str.length();i++){ System.out.print(str.charAt(i)+"、"); } System.out.println(); //查找指定字符在字符串中第一次出现的位置,若字符串中没有要查找的字符返回-1 System.out.println("j第一次出现的位置是："+str.indexOf('。')); //返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。若字符串中没有要查找的字符返回-1 System.out.println("o在脚标2后第一次出现的索引："+str.indexOf('o', 2)); //返回指定子字符串在此字符串中第一次出现处的索引。 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。和上面相同，区别在于把单引号换成双引号，字符可以是多个的了 //截取字符串，从指定脚标开始截取，包含指定脚标 System.out.println("截取新字符串，从脚标2开始截取："+str.substring(2)); //截取字符串，从指定脚标截取到指定脚标，包含开始脚标，不包含结束脚标,注意结束脚标不能比字符串长度大，也不能比开始脚标小，否则会脚标越界异常 System.out.println("截取新字符串，开始脚标为2，结束脚标为3："+str.substring(2, 3)); }
String的转换功能
/*String类的转换功能 * getBytes() 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。 getBytes(Charset charset) 使用给定的 charset 将此 String 编码到 byte 序列，并将结果存储到新的 byte 数组。 getBytes(String charsetName) 使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。 getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此字符串复制到目标字符数组。 toCharArray() 将此字符串转换为一个新的字符数组。 copyValueOf(char[] data) 返回指定数组中表示该字符序列的 String。 copyValueOf(char[] data, int offset, int count) 返回指定数组中表示该字符序列的 String。 valueOf(boolean b) 返回 boolean 参数的字符串表示形式。 valueOf(char c) 返回 char 参数的字符串表示形式。 valueOf(char[] data) 返回 char 数组参数的字符串表示形式。 valueOf(char[] data, int offset, int count) 返回 char 数组参数的特定子数组的字符串表示形式。 valueOf(double d) 返回 double 参数的字符串表示形式。 valueOf(float f) 返回 float 参数的字符串表示形式。 valueOf(int i) 返回 int 参数的字符串表示形式。 valueOf(long l) 返回 long 参数的字符串表示形式。 valueOf(Object obj) 返回 Object 参数的字符串表示形式。 trim() 返回字符串的副本，忽略前导空白和尾部空白。 toLowerCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为小写。 toLowerCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。 toString() 返回此对象本身（它已经是一个字符串！）。 toUpperCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。 toUpperCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。 concat(String str) 将指定字符串连接到此字符串的结尾。 统计大写小写数字的个数 把字符串的首字母转成大写，其余为小写 */ public static void transform(){ String str = "youjob@yeah.net"; //使用平台的默认字符集将此 String 编码为 byte 序列 byte[] bs = str.getBytes(); for(int i=0;i<bs.length;i++){ System.out.print(bs[i]+" "); } System.out.println(); //getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此字符串复制到目标字符数组。但是截取的字符串，不能比字符数组长度减去存放其实脚标的值大，否则脚标越界异常 char[] ch = {'a','b','c','d','e','a','b','c','d','e'}; str.getChars(2, 7, ch, 2); for (int i = 0; i < ch.length; i++) { System.out.print(ch[i]+" "); } System.out.println(); //将字符串转换为新的字符数组 char[] ch1 = str.toCharArray(); for (int i = 0; i < ch1.length; i++) { System.out.print(ch1[i]+" "); } System.out.println(); //给定一个字符数组，将其转变为字符串 System.out.println(str.copyValueOf(ch)); System.out.println(new String(ch)); //将数组中的指定元素，转变为字符串,三个参数，数组、开始脚标、截取长度 System.out.println(str.copyValueOf(ch, 2, 4)); //将一些其他类型数据转换为字符串 System.out.println(str.valueOf(false)); System.out.println(str.valueOf('a')); System.out.println(str.valueOf(ch)); System.out.println(str.valueOf(3.14)); System.out.println(str.valueOf(3.14)); System.out.println(str.valueOf(123)); System.out.println(str.valueOf(ch, 2, 4)); //trim() 返回字符串的副本，忽略前导空白和尾部空白。开头和结尾空格不能去除 String testStr = " youjob @yeah .ne t "; System.out.println("去除空格"+testStr.trim()); //大小写转换，数字或非字符不受影响， testStr = "YOujob@Yeah.net"; System.out.println("转小写："+testStr.toLowerCase()); System.out.println("转大写："+testStr.toUpperCase()); //将指定字符串连接到此字符串的结尾。 System.out.println("将testStr连接到str:"+str.concat(testStr)); //toString() 我们在字符串和非字符串+操作时，其实就是非字符串调用此方法将自己装变为字符串，然后运算 Boolean boo = false; str = boo.toString(); System.out.println(str); }
统计大写小写数字的个数小例子
/*计算字符串中大写字母个数，小写字母个数，数字个数 * 分析：首先我们要有一个字符串，其次，我们要分析，怎么判断一个字符他是不是字母，怎么判断他是不是大小写 * 我们知道字符串是Unicode编码，那么字母其实对应的是数字，所以我们只有判断他的区间，就可以判断大小写 */ public static void numString(){ Scanner sc = new Scanner(System.in); System.out.println("请输入字符串："); String str = sc.nextLine(); //声明三个int类型变量来作为大写字母个数 小写字母个数 非字母个数 int bigCount = 0; int smallCount = 0; int numberCount = 0; char[] ch = str.toCharArray(); for(int i = 0;i<ch.length;i++){ if(ch[i]>='A'&&ch[i]<='Z'){ bigCount++; }else if (ch[i]>='a'&&ch[i]<='z') { smallCount++; }else if(ch[i]>=0&&ch[i]<=9){ numberCount++; } } System.out.println("大写字母个数为："+bigCount); System.out.println("小写字母个数为："+smallCount); System.out.println("数字个数为："+numberCount); }
把字符串的首字母转成大写，其余为小写，小例子
/* 把字符串的首字母转成大写，其余为小写，这我们首先要有一个字符串，然后要获取字符串首字母，把首字母大写，然后获取首字母后边的字母，全部小写 * 用到了substring(int beginIndex) substring(int beginIndex, int endIndex) toLowerCase() toUpperCase() */ public static void test(){ Scanner sc = new Scanner(System.in); System.out.println("请输入字符串："); String str = sc.nextLine(); //获取第一个字符 String strStart = str.substring(0,1); //获取第一个字符后面的字符 String strLase = str.substring(1); //把获取的第一个字符大写 String big = strStart.toUpperCase(); //把获取的首字符后面的字符小写 String samll = strLase.toLowerCase(); //重组字符串 str = big+samll; System.out.println("转变后的字符串："+str); }
String其他操作
/*替换功能 String replace(char old,char new) String replace(String old,String new) 切割 String[] split(String regex) 按字典顺序比较两个字符串 int compareTo(String str) int compareToIgnoreCase(String str) */ public static void othersString(){ String str = "youyob@yeah.net"; //替换功能，把老的字符或字符串，替换成新的字符或字符串,注意字符只能替换成字符，字符串只能替换成字符串（对象） System.out.println("把str中的所有y都替换成x"+str.replace('y', 'x')); System.out.println("把str中的所有yo都替换成x"+str.replace("yo", "x")); //切割字符串split(String regex) 根据给定正则表达式的匹配拆分此字符串。 //split(String regex, int limit) 根据匹配给定的正则表达式来拆分此字符串。 拆分次数实际就是拆分后数组长度,拆分次数过多（超出实际可拆分），不会报错 str = "abc.abc.abc.abc"; String[] s = str.split("\."); for (int i = 0; i < s.length; i++) { System.out.print(s[i]+" "); } System.out.println(); //拆分两次 String[] s1 = str.split("\.", 2); for (int i = 0; i < s1.length; i++) { System.out.print(s1[i]+" "); } System.out.println(); //按字典顺序比较字符串：compareTo(),str.compareTo(String others)如果此字符串对象位于参数字符串之前，结果为负整数，如果此字符串对象位于参数字符串之后，结果为正整数，，相等为0(只有在equals返回true才会是0) // compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。 //按字典顺序比较字符串 String str3 = "a"; String str4 = "b"; String str5 = "g"; String str6 = "A"; System.out.println(str3.compareTo(str5)); System.out.println(str4.compareTo(str3)); System.out.println(str3.compareToIgnoreCase(str6)); System.out.println(str3.compareTo(str6)); }
在字符串中获取指定字符串出现次数
/*获取一个字符串中指定字符串出现的次数，首先我们需要一个字符串，比如cnonabciojiabcnonabcio,在这个字符串中有多少个abc呢，我们应该怎么做呢，我们知道String类的 * 拆分功能，那么我们可不可以通过以指定字符串拆分来获取个数呢，假如有一个指定字符串则拆分一次，拆分后数组长度2，有两个，拆分两次，拆分后长度3 * 通过上面我们知道了，指定字符串拆分，指定字符串出现次数总是比拆分后数组长度小1 * 但是我们要考虑这么一种情况，如果字符串以指定字符串开头或结尾，那么拆分后的情况和上边是不同的 * 假如只开头和结尾出现一次，那么寻求的次数应该和数组长度一样，假如开头和结尾出现两次，那么寻求次数比数组长度>1 */ public static void stringTest(){ String str = "cnonabciojiabcnonabciocnonabciojiabcnonabciocnonabciojiabcnonabciocnonabciojiabcnonabciocnonabciojiabcnonabcio"; String str1 = "abcnonabciojiabcnonabcioabc"; String str2 = "abcnonabciojiabcnonabciobc"; //通过字符串str来验证 String[] st = str.split("abc"); if(str.startsWith("abc")&&str.endsWith("abc")){ System.err.println("字符串str指定字符串abc出现次数为："+(st.length+1)); }else if (str.startsWith("abc")|str.endsWith("abc")) { System.err.println("字符串str指定字符串abc出现次数为："+st.length); }else { System.out.println("字符串str指定字符串abc出现次数为："+(st.length-1)); } //通过字符串str1来验证 String[] st1 = str.split("abc"); System.out.println("st1数组长度为："+st1.length); if(str1.startsWith("abc")&&str1.endsWith("abc")){ System.out.println("字符串str1指定字符串abc出现次数为："+(st1.length+1)); }else if (str1.startsWith("abc")|str1.endsWith("abc")) { System.out.println("字符串str1指定字符串abc出现次数为："+st1.length); }else { System.out.println("字符串str1指定字符串abc出现次数为："+(st1.length-1)); } //通过字符串str2来验证 String[] st2 = str.split("abc"); System.out.println("st2数组长度为："+st2.length); if(str2.startsWith("abc")&&str2.endsWith("abc")){ System.out.println("字符串str2指定字符串abc出现次数为："+(st2.length+1)); }else if (str2.startsWith("abc")|str2.endsWith("abc")) { System.out.println("字符串str2指定字符串abc出现次数为："+st2.length); }else { System.out.println("字符串str2指定字符串abc出现次数为："+(st2.length-1)); } /*当然我们如果遇到在字符串中获取指定字符串(字符)出现次数，还可以通过下面几种方法 把字符串转换成字符数组，查找数组中出现次数 把字符串中该字符替换为""，比较前后长度差，就是获取的次数 第三种就是如上的分割了,我们通过一个小例子，加以验证，并比较三种的性能 ，以str为例验证 */ //第一种 指定字符 指定变量作为字符出现次数 注意我们看不出时间上的变化是因为我们给定的字符串太小，小差别忽略到我们看不到 char c = 'a'; int num = 0; //计时开始 long startTime = System.currentTimeMillis(); char[] ch = str.toCharArray(); for(int i = 0;i<ch.length;i++){ if(ch[i]==c){ num++; } } long endTime = System.currentTimeMillis(); System.out.println("str字符串中指定字符a出现次数："+num); long time = endTime-startTime; System.out.println("总共用时："+time); //第二种， String strTest = str.replaceAll("a", ""); //出现次数 int num1 = str.length()-strTest.length(); System.out.println("指定出现次数为："+num1); //第三种 //通过字符串str2来验证 String[] st3 = str.split("a"); System.out.println("st3数组长度为："+st3.length); if(str.startsWith("a")&&str.endsWith("a")){ System.out.println("字符串str指定字符串a出现次数为："+(st3.length+1)); }else if (str.startsWith("a")|str.endsWith("a")) { System.out.println("字符串str指定字符串a出现次数为："+st3.length); }else { System.out.println("字符串str指定字符串a出现次数为："+(st3.length-1)); } }
对字符串中字符进行自然顺序排序
//对字符串中字符进行自然排序 我们把字符串转换成字符数组，然后排序，最后再转换成字符串 public static void stringDe(){ String str = "1221aasafd!"; char[] ch = str.toCharArray(); //将字符数组排序 Arrays.sort(ch); str = String.copyValueOf(ch); //str = String.valueOf(ch); System.out.println("输出字符串："+str); }
格式化字符串
/*格式化字符串 * String类的静态format()方法用于创建格式化字符串。format()方法有两种重载形式 * static String format(Locale l, String format, Object... args) 使用指定的语言环境、格式字符串和参数返回一个格式化字符串。 * I：格式化过程中要用到的语言环境，如果I为null，则不进行本地化 * format：格式字符串 * args：格式字符串中由格式说明符引用的参数。如果还有格式说明符以外的参数，则忽略这些额外的参数。此参数的数目是可变的，可以为0 static String format(String format, Object... args) 使用指定的格式字符串和参数返回一个格式化字符串。 format：待格式化的字符串 args：格式字符串中由格式说明符引用的参数。如果还有格式说明符以外的参数，则忽略这些额外的参数。此参数的数目是可变的，可以为0 * */ public static void formatString(){ //使用给定格式对日期格式化 Date d = new Date(); System.out.println("使用给定语言环境对日期格式化，当前天："+String.format("%te", d)); System.out.println("使用给定语言环境对日期格式化，当前月份简称:"+String.format("%tb", d)); System.out.println("使用给定语言环境对日期格式化，月份全称:"+String.format("%tB", d)); System.out.println("使用给定语言环境对日期格式化，4位年份:"+String.format("%tY", d)); //对时间格式化 System.out.println("2位数字的24时制的小时："+String.format("%tH", d)); System.out.println("2位数字的12时制的小时："+String.format("%tI", d)); System.out.println("时区缩写的字符串："+String.format("%tZ", d)); //格式化常见的日期组合 System.out.println("年月日格式："+String.format("%tF", d)); System.out.println("时分秒格式PM(AM)(12时制)："+String.format("%tr", d)); //常规类型格式化 System.out.println("结果被格式化为字符串："+String.format("%s", 4.34)); System.out.println("结果被格式化为布尔型显示："+String.format("%b",3>5 )); }
StringBuffer
符串缓冲区，缓冲区用于存储数据，所以也称之为容器。字符串的组成原理就是通过该类实现的。
线程安全的可变字符序列。（字符串是固定不变的内容是常量，这是StringBuffer和String的区别）一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。
可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。
StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。
例如，如果 z 引用一个当前内容为 "start" 的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含 "startle"，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含 "starlet"。
通常，如果 sb 引用 StringBuilder 的一个实例，则 sb.append(x) 和 sb.insert(sb.length(), x) 具有相同的效果。
当发生与源序列有关的操作（如源序列中的追加或插入操作）时，该类只在执行此操作的字符串缓冲区上而不是在源上实现同步。
每个字符串缓冲区都有一定的容量。只要字符串缓冲区所包含的字符序列的长度没有超出此容量，就无需分配新的内部缓冲区数组。如果内部缓冲区溢出，则此容量自动增大。从 JDK 5 开始，为该类补充了一个单个线程使用的等价类，即 StringBuilder。与该类相比，通常应该优先使用 StringBuilder 类，因为它支持所有相同的操作，但由于它不执行同步，所以速度更快。
package you.demo.stringBuffer; import java.util.Scanner; /*线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。 可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。 StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。 例如，如果 z 引用一个当前内容为 "start" 的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含 "startle"，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含 "starlet"。 通常，如果 sb 引用 StringBuilder 的一个实例，则 sb.append(x) 和 sb.insert(sb.length(), x) 具有相同的效果。 当发生与源序列有关的操作（如源序列中的追加或插入操作）时，该类只在执行此操作的字符串缓冲区上而不是在源上实现同步。 每个字符串缓冲区都有一定的容量。只要字符串缓冲区所包含的字符序列的长度没有超出此容量，就无需分配新的内部缓冲区数组。如果内部缓冲区溢出，则此容量自动增大。从 JDK 5 开始，为该类补充了一个单个线程使用的等价类，即 StringBuilder。与该类相比，通常应该优先使用 StringBuilder 类，因为它支持所有相同的操作，但由于它不执行同步，所以速度更快。 从以下版本开始： JDK1.0 * * * StringBuffer和String的区别： * StringBuffer: 线程安全的，内容是可变的 * String: 字符串是常量；它们的值在创建之后不能更改。 * 注意我们经常看到字符串初始化后，我们还能再次为其初始化，这是我们的一个误区， * 我们所说的String不能改变是指string的字符串已经声明，这个字符串在内存中是不变的， * 我们再次初始化只是把另一个字符串的引用给了字符串变量，而原来的字符串仍在，没变 * 而StringBuffer则不同，StringBuffer则是直接改变字符串，在原有字符串基础上改变，改变后生成一个新的字符串，原字符串不存在（即新字符串地址和老字符串地址相同） * */ public class StringBufferDemo { public static void main(String[] args) { // TODO Auto-generated method stub // constructedStringBuffer(); // addStringBuffer(); // deleteStringBuffer(); // replaceStringBuffer(); // interceptStringBuffer(); // reverseStringBuffer(); // changeStringBuffer(); testStringBuffer(); } /*StringBuffer() 构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。 StringBuffer(CharSequence seq) 构造一个字符串缓冲区，它包含与指定的 CharSequence 相同的字符。 StringBuffer(int capacity) 构造一个不带字符，但具有指定初始容量的字符串缓冲区。 StringBuffer(String str) 构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。 注意：StringBuffer中有两种获取长度的方法，length（）和caoacity()，这两种方法的区别在于，length()获取的是StringBuffer中字符串的长度，capacity()获取的是StringBuffer的容量 */ public static void constructedStringBuffer(){ StringBuffer sb1 = new StringBuffer(); StringBuffer sb2 = new StringBuffer("adc"); StringBuffer sb3 = new StringBuffer(32); System.out.println("字符串缓冲区对象sb1的初始容量为："+sb1.capacity()); System.out.println("字符串缓冲区对象sb1的初始容量为："+sb2.length()); //StringBuffer的容量为默认容量（给定容量）+字符串长度 System.out.println("字符串缓冲区对象sb2的初始容量为："+sb2.capacity()); System.out.println("字符串缓冲区对象sb2的初始值为："+sb2.toString()); System.out.println("字符串缓冲区对象sb3的初始容量为："+sb3.capacity()); } /* * 添加功能： * public StringBuffer append(int i) ： 将 int 参数的字符串表示形式追加到此序列 返回：当前对象 * public StringBuffer insert(int offset, int i): 将 int 参数的字符串表示形式插入此序列中 返回： 当前对象 */ public static void addStringBuffer(){ StringBuffer sb = new StringBuffer("youjob"); sb.append(1); System.out.println("输出："+sb.toString()); //在脚标3的位置插入int类型1 sb.insert(3, 1); //通过此次输出我们会发现StringBuffer改变了字符串，这和String的一经初始化不能改变是不同的 System.out.println("输出："+sb.toString()); } /* * 删除功能： * StringBuffer delete(int start, int end) ： 从指定位置开始，到指定位置结束之间的数据在该字符序列中删除 * StringBuffer deleteCharAt(int index) : 在该字符序列中，删除给定位置上的字符 */ public static void deleteStringBuffer(){ StringBuffer sb = new StringBuffer("youjob"); //删除从脚标2到脚标4的字符串，包头不包尾,注意脚标越界异常 sb.delete(2, 4); System.out.println("删除从2到4的字符串结果为："+sb.toString()); //删除指定脚标字符 注意脚标越界异常 sb.deleteCharAt(3); System.out.println("删除指定脚标字符为："+sb.toString()); } /* * 替换功能： * StringBuffer replace(int start, int end, String str) : 从指定位置开始，到指定位置结束中的数据，使用给定的字符串替换 */ public static void replaceStringBuffer(){ StringBuffer sb = new StringBuffer("youjob"); //从指定位置到结束位置，替换字符串,包头不包尾，尾部脚标对应字符不会被替换，替换的字符串和被替换的字符串可以不用有形同字符，此时可以将这两个看做字符串对象，而字符串是对象内容 sb.replace(2, 5, "ststst"); System.out.println(sb.toString()); } /* * 截取功能： * String substring(int start) : 从指定位置开始，截取字符序列 String substring(int start, int end) : 从指定位置开始，到指定位置结束，截取字符序列 */ public static void interceptStringBuffer(){ StringBuffer sb = new StringBuffer("youjob"); //从指定位置开始截取字符串，返回的是字符串对象，是被截取后的部分 System.out.println(sb.substring(3)); //从指定位置开始截取，截取到指定位置，注意脚标越界，包头不包尾，返回的是被截取的部分 System.out.println(sb.substring(2, 4)); } /* * 反转功能： * StringBuffer reverse() * * "abcde" 反转--> "edcba" */ public static void reverseStringBuffer(){ StringBuffer sb = new StringBuffer("youjob"); //反转功能是将字符串缓冲器中字符串，末尾脚标变成开始脚标，一次类推 sb.reverse(); System.out.println(sb.toString()); } /* * StringBuffer 和 String的相互转换 : 对象之间相互转换是为了使用对象的特有方法 * * append() String---> StringBuffer * toString() StringBuffer --> String */ public static void changeStringBuffer(){ StringBuffer sb = new StringBuffer("youjob"); String str = "bojuoy"; //字符串对象转换成StringBuffer对象 StringBuffer ss = new StringBuffer().append(str); System.out.println("StringBuffer转换成String："+sb.toString()); System.out.println("String转换成StringBuffer："+ss.toString()); } /* * 练习：从键盘录入一个字符串，反转后输出 * * 分析： * 键盘输入字符串 * 字符串 转换成 StringBuffer * 反转功能 * StringBuffer 转换成 String * 输出 */ public static void testStringBuffer(){ Scanner sc = new Scanner(System.in); System.out.println("从键盘输入字符串反转输出-请输入："); String str = sc.nextLine(); StringBuffer sb = new StringBuffer().append(str); System.out.println("反转输出："+sb.reverse().toString() ); } }
验证连接字符串，String之+和StringBuffer的append谁的效率高
/*从上面我们知道StringBuffer的append()同样可以添加字符串，而String可以通过运算符+实现，那么谁的效率更高呢，下面验证 * */ public static void test(){ String str = "qbc"; StringBuffer sb = new StringBuffer("qbc"); //声明两个long类型的变量记录操作前时间和操作后时间，用以比较效率 Long startTimeStr = System.currentTimeMillis(); for (int i = 0; i < 10000; i++) { str = str+i; } System.out.println("输出str："+str); Long endTimeStr = System.currentTimeMillis(); Long strTime = endTimeStr-startTimeStr; Long startTimeSB = System.currentTimeMillis(); for (int i = 0; i < 10000; i++) { sb.append(i); } System.out.println("输出字符串缓冲器字符串："+sb.toString()); Long endTimeSb = System.currentTimeMillis(); Long sbTime = endTimeSb-startTimeSB; if(sbTime > strTime){ System.out.println("StringBuffer添加字符串效率不如String运用操作符+添加字符串！"); }else System.out.println("String运用操作符+添加字符串效率不如StringBuffer添加字符串效率！"); System.out.println("String效率"+strTime); System.out.println("StringBuffer效率"+sbTime); }
StringBuilder
一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。
在 StringBuilder 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串生成器中。append 方法始终将这些字符添加到生成器的末端；而 insert 方法则在指定的点添加字符。
例如，如果 z 引用一个当前内容为 "start" 的字符串的生成器对象，则该方法调用 z.append("le") 将使字符串生成器包含 "startle"，而 z.insert(4, "le") 将更改字符串生成器，使之包含 "starlet"。
通常，如果 sb 引用 StringBuilder 的实例，则 sb.append(x) 和 sb.insert(sb.length(), x) 具有相同的效果。每个字符串生成器都有一定的容量。只要字符串生成器所包含的字符序列的长度没有超出此容量，就无需分配新的内部缓冲区。如果内部缓冲区溢出，则此容量自动增大。
将 StringBuilder 的实例用于多个线程是不安全的。如果需要这样的同步，则建议使用 StringBuffer。
- 从以下版本开始：
- 1.5
-
StringBuilder类和StringBuffer类的功能完全一致。那么为什么为出现StringBuilder类呢？
后者更高效
StringBuffer和StringBuilder的区别？
线程安全问题。 安全了，效率就低了。
效率高了，可能就不安全了。
封装类--基本数据类型对象包装类
我们前面学过了8种基本数据类型，但是我们只能对他们做一些简单的操作，如果想做一些复杂的操作，做不了。为了帮助我们实现这个想法，java就对基本数据类型进行了封装。也就是说每一种基本数据类型都对应着一个对象了。方便我们使用更多的功能。 举例：封装类的好处。 比如说，我说我们要判断一个数据在int所表示的范围内，我们要计算2的31次方的值。
常见的应用就是：基本数据类型和字符串进行相互转换 以int类型的封装对象Integer为例学习基本数据类型的封装类对象。 Integer的构造方法 Integer(int value); Integer(String value); String和int数据的相互转换
在JDK5以后，对封装类对象的创建有了简化的 格式： 例如：Integer i = new Integer(20);可以直接写出 Integer i = 20; 装箱操作。参与运算要求参与运算的数据类型一致：而i+20可以计算，这里面有一个拆箱的操作(通过intValue方法自动实现)。 注意：在使用时，需要判断一下i是否为null。简化书写，有好处，也有弊端。
package you.demo.integer; /* * Integer 类在对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型的字段。 此外，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。 实现注意事项：“bit twiddling”方法（如 highestOneBit 和 numberOfTrailingZeros）的实现基于 Henry S. Warren, Jr.撰写的 Hacker's Delight（Addison Wesley, 2002）中的一些有关材料。 从以下版本开始： JDK1.0 * 我们前面学过了8种基本数据类型，但是我们只能对他们做一些简单的操作，如果想做一些复杂的操作，做不了。 * 为了帮助我们实现这个想法，java就对基本数据类型进行了封装。 * 也就是说每一种基本数据类型都对应着一个对象了。方便我们使用更多的功能。 * * byte -- Byte * short -- Short * int -- Integer * long -- Long * * float -- Float * double -- Double * * char -- character * boolean -- Boolean * * 构造函数： * * public Integer(int value) : 把int数据 包装成 Integer对象 * public Integer(String s) : 把String(必须是由数字字符组成)数据 包装成 Integer对象 * * 字段： * static int MAX_VALUE * static int MIN_VALUE * * 掌握的方法： * 10进制 --> 其他 * public static String toBinaryString(int i) 把十进制 转换成 二进制 * public static String toHexString(int i) 把十进制 转换成 十六进制 * public static String toOctalString(int i) 把十进制 转换成八进制 * public static String toString(int i, int radix) 把十进制 转换成指定的进制 * * 其他 --> 10 * public static Integer valueOf(String s, int radix) * */ public class IntegerDemo { public static void main(String[] args) { // TODO Auto-generated method stub constructedInteger(); fieldInteger(); changeInteger(); autoboxingAndUnboxingInteger(); changeStringWithInteger(); } /* * 构造函数： * * public Integer(int value) : 把int数据 包装成 Integer对象 * public Integer(String s) : 把String(必须是由数字字符组成)数据 包装成 Integer对象 */ public static void constructedInteger(){ Integer i = new Integer(12); Integer j = new Integer("234"); System.out.println("包int数据包装成Internet对象"+i); System.out.println("包int数据包装成Internet对象,将其装换成字符串输出"+i.toString()); System.out.println("字符串包装成integer对象"+j); } /*字段： * static int MAX_VALUE integer对象最大值 * static int MIN_VALUE integer对象最小值 */ public static void fieldInteger(){ int i = Integer.MAX_VALUE;//自动拆箱 int j = Integer.MIN_VALUE; System.out.println("最大值："+i); System.out.println("最小值："+j); } /*进制转换 * 10进制 --> 其他 * public static String toBinaryString(int i) 把十进制 转换成 二进制 * public static String toHexString(int i) 把十进制 转换成 十六进制 * public static String toOctalString(int i) 把十进制 转换成八进制 * public static String toString(int i, int radix) 把十进制 转换成指定的进制 * * 其他 --> 10 后边需要指明前面是什么进制 * public static Integer valueOf(int i) * public static Integer valueOf(String s)字符串需要全部是整数类型 * public static Integer valueOf(String s, int radix) 后边需要指明解析前面字符串用什么进制 * */ public static void changeInteger(){ Integer i = 156; //自动装箱 Integer.valueOf(15) //把十进制转换成二进制 System.out.println(i.toBinaryString(i)); //把十进制转换为十六进制 System.out.println(i.toHexString(i)); //把十进制转换成八进制 System.out.println(i.toOctalString(i)); //把十进制转换成指定的进制 System.out.println(i.toString(i, 8)); String str = "9"; //其他类型转换为十进制 指定进制 System.out.println(Integer.valueOf(str)); System.out.println(Integer.valueOf("9c", 16)); } /* * JDK5以后 出现包装类的简化形式 * * int --> Integer 自动装箱 i = Integer.valueOf(25); * Integer --> int 自动拆箱 i.intvalue(); * Integer i = new Integer(5); * i = i + 20; * 发现 i与 20的 类型不统一， 不能进行运行，必须要做类型统一 * * 可以把Integer类型i 转变成 int数据 * i.intvalue() 通过这个方法 得到一个int数据，再参与运算 * i.intvalue() + 20 = 25 * i = new Integer(25); */ public static void autoboxingAndUnboxingInteger(){ Integer i = 5; i = i + 5; String str = i.toString()+"aa"; System.out.println("上述实现了自动拆装箱的过程，拆箱时自动调用intvalue()方法"+str); } /* * String和int数据的相互转换 * * valueOf(int i) 返回一个表示指定的 int 值的 Integer 实例。 valueOf(String s) 返回保存指定的 String 的值的 Integer 对象。 valueOf(String s, int radix) 返回一个 Integer 对象，该对象中保存了用第二个参数提供的基数进行解析时从指定的 String 中提取的值。 intValue() 以 int 类型返回该 Integer 的值。 */ public static void changeStringWithInteger(){ String str = "127"; int i =99; //将int类型转换成一个Integer对象 System.out.println("将int类型转换成Integer对象，将Integer转换成String"+(Integer.valueOf(i).toString()+"aa")); //将字符串的值返回一个Integer对象 System.out.println("将字符串转换成Integer对象"+Integer.valueOf(str)); //将字符串转换成一个十进制，前面是字符串参数，后面是指定前面解析字符串所用进制 System.out.println("将字符串转换成integer对象，指定按什么进制解析字符串："+Integer.valueOf("9c", 16)); //将integer对象转换为int值，这是拆箱操作 System.out.println("拆箱操作："+new Integer(i).intValue());//装箱 拆箱操作 } }
一个字符串"34 -12 56 93 27" ，请把字符串中的数据进行排序。
/*一个字符串"34 -12 56 93 27" ，请把字符串中的数据进行排序。 * 我们知道Arrays中有排序的方法，但Arrays是针对数组的，所以我们想要对其进行排序，应该先把这个字符串转换成数组 * 通过上面给出的字符串，我们可以看出这是一个元素为数据的字符串，那么我们可以将其转换成String数组， * 也可以将其转换成int数组，排序完后，再将数组转换为String输出打印即可，下面以两种方法一一验证 */ public static void sortTest(){ String str = "34 -12 56 93 27"; //将字符串转换成数组，利用切割 String[] sa = str.split(" "); //对字符串数组排序 Arrays.sort(sa); //将字符串数组重新组合成字符串 StringBuilder sb = new StringBuilder(); //System.out.println("对排序后的字符串数组输出打印："+sa.toString());这种打印打印的是数组的地址，而不是数组中的元素 System.out.println("通过这种可以把数组中的元素打印出来，用的是Arrays.toString（Object ob）:"+Arrays.toString(sa)); for (int i = 0; i < sa.length; i++) { sb.append(sa[i]).append(" "); } System.out.println("对排序后的字符串数组输出打印："+sb.toString()); /*上面是通过转换成字符串数组进行的操作，那么转换成int数组呢 * 我们知道没有直接把String[]数组转换成int数组的方法，但有一点我们是知道的那就是转换后的String数组和int数组的长度是一致的， * 那么我们可不可以先把声明一个定长的int数组，然后把String数组元素添加进去呢，之后再进行排序,排序后将int数组直接转换成字符串 */ String str1 = "34 -12 56 93 27"; //将字符串转换成数组，利用切割 String[] sa1 = str.split(" "); //声明定长int数组 int[] ia = new int[sa1.length]; for (int i = 0; i < ia.length; i++) { //parseInt(String str) 返回包含在由str指定的字符串中的数字的等价整数值 ia[i] = Integer.parseInt(sa1[i]); //ia[i] = Integer.valueOf(sa1[i]).intValue();//装箱和拆箱的过程 } //对int数组进行排序 Arrays.sort(ia); System.out.println("将int类型数组输出打印："+Arrays.toString(ia)); }
面试题： byte常量池
/* * 面试题： byte常量池 * 自从有了自动装箱后，在byte范围内的值直接赋值给包装类的时候，是从常量池里获取的。 */ public static void test(){ Integer i1 = new Integer(127); Integer i2 = new Integer(127); System.out.println(i1==i2); System.out.println(i1.equals(i2)); Integer i3 = new Integer(345); Integer i4 = new Integer(345); System.out.println(i3==i4); System.out.println(i3.equals(i4)); //byte范围内，从常量池取值 这等同于 Integer i5 = new Integer(); i5 = 127; Integer i5 = 127; Integer i6 = 127; System.out.println(i5 == i6); System.out.println(i5.equals(i6)); //byte范围之外，就相当于Integer i7 = new Integer（145）；创建两个对象，一个Integer引用，一个存放int值得引用 Integer i7 = 145; Integer i8 = 145; System.out.println(i7 == i8); System.out.println(i7.equals(i8)); }
DecimalFormat
package you.demo.decimalFormat; import java.text.DecimalFormat; /*DecimalFormat 是 NumberFormat 的一个具体子类，用于格式化十进制数字。该类设计有各种功能，使其能够解析和格式化任意语言环境中的数，包括对西方语言、阿拉伯语和印度语数字的支持。它还支持不同类型的数，包括整数 (123)、定点数 (123.4)、科学记数法表示的数 (1.23E4)、百分数 (12%) 和金额 ($123)。所有这些内容都可以本地化。 * 符号 位置 本地化？ 含义 0 数字 是 阿拉伯数字 # 数字字 是 阿拉伯数字，如果不存在则显示为 0 . 数字 是 小数分隔符或货币小数分隔符 - 数字 是 减号 , 数字 是 分组分隔符 E 数字 是 分隔科学计数法中的尾数和指数。在前缀或后缀中无需加引号。 ; 子模式边界 是 分隔正数和负数子模式 % 前缀或后缀 是 乘以 100 并显示为百分数 u2030 前缀或后缀 是 乘以 1000 并显示为千分数 ¤ (u00A4) 前缀或后缀 否 货币记号，由货币符号替换。如果两个同时出现，则用国际货币符号替换。如果出现在某个模式中，则使用货币小数分隔符，而不使用小数分隔符。 ' 前缀或后缀 否 用于在前缀或或后缀中为特殊字符加引号，例如 "'#'#" 将 123 格式化为 "#123"。要创建单引号本身，请连续使用两个单引号："# o''clock"。 构造函数 * DecimalFormat() 使用默认模式和默认语言环境的符号创建一个 DecimalFormat。 DecimalFormat(String pattern) 使用给定的模式和默认语言环境的符号创建一个 DecimalFormat。 DecimalFormat(String pattern, DecimalFormatSymbols symbols) 使用给定的模式和符号创建一个 DecimalFormat。 方法： applyPattern(String pattern) 将给定的模式应用于此 Format 对象。 format(double number, StringBuffer result, FieldPosition fieldPosition) 格式化一个 double 值，以生成一个字符串。 StringBuffer format(long number, StringBuffer result, FieldPosition fieldPosition) 格式化一个 long 值，以生成一个字符串。 StringBuffer format(Object number, StringBuffer toAppendTo, FieldPosition pos) 格式化一个数，并将所得文本追加到给定的字符串缓冲区。 setGroupingSize(int newValue) 设置分组大小。 setGroupingUsed(false) 设置是否支持分组。 */ public class DecimalFormatDemo { //使用实例化对象设置格式化模式 static public void SimgleFormat(String pattern,double value){ //实例化DecimalFormat对象使用给定的模式和默认语言环境的符号创建一个 DecimalFormat。 DecimalFormat df = new DecimalFormat(pattern); //调用format方法格式化传入数字 String output = df.format(value); System.out.println("按照格式化模板格式化数字："+pattern+"模板"+value+"待格式化数字"+output+"格式化结果"); } //使用applyPattern(String str)方法对数字进行格式化 public static void UseApplyPatternMethodFormat(String pattern,double value){ //创建DecimalFormat对象 DecimalFormat df = new DecimalFormat(); //调用applyPattern方法设置格式化模板 df.applyPattern(pattern);; //调用format方法格式化参数数字 String output = df.format(value); System.out.println("按照格式化模板格式化数字："+pattern+"模板"+value+"待格式化数字"+output+"格式化结果"); } public static void main(String[] args) { // TODO Auto-generated method stub //按照格式化模板格式化数字，该位存在数字即显示，不存在的不显示，注意前面是，写成.会报错(java.lang.IllegalArgumentException: Multiple decimal separators in pattern "###.###.###")不合法的参数异常 SimgleFormat("###,###.###", 123456.789); SimgleFormat("00000000.###KG", 123456.789); //按照格式化模板格式化数字，不存在的以0显示 SimgleFormat("000000.000", 123.78); //调用UseApplyPatternMethodFormat方法，将数字转化为百分位数字 UseApplyPatternMethodFormat("#.###%", 0.789); //将小数点后格式化为两位 UseApplyPatternMethodFormat("###.##", 123456.789); //将数字转化为千分位数字,小数点后保存两位 UseApplyPatternMethodFormat("0.00u2030", 0.789); DecimalFormat df = new DecimalFormat(); df.setGroupingSize(2); String output = df.format(123456.789); System.out.println("setGroundingSize()方法设置分组大小！"+output); //设置不允许分组 df.setGroupingUsed(false); df.setGroupingSize(2); String output1 = df.format(123456.789); System.out.println("setGroundingUsed()方法设置是否允许分组："+output1); df.setGroupingUsed(true); df.setGroupingSize(2); String output2 = df.format(123456.789); System.out.println("setGroundingUsed()方法设置是否允许分组："+output2); } }
Math
package you.demo.math; /*Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。 与 StrictMath 类的某些数学方法不同，并非 Math 类所有等价函数的实现都定义为返回逐位相同的结果。 此类在不需要严格重复的地方可以得到更好的执行。 默认情况下，很多 Math 方法仅调用 StrictMath 中的等价方法来完成它们的实现。 建议代码生成器使用特定于平台的本机库或者微处理器指令（可用时）来提供 Math 方法更高性能的实现。 这种更高性能的实现仍然必须遵守 Math 的规范。 实现规范的质量涉及到两种属性，即返回结果的准确性和方法的单调性。 浮点 Math 方法的准确性根据 ulp（units in the last place，最后一位的进退位）来衡量。 对于给定的浮点格式，特定实数值的 ulp 是包括该数值的两个浮点值的差。 当作为一个整体而不是针对具体参数讨论方法的准确性时，引入的 ulp 数用于任何参数最差情况下的误差。 如果一个方法的误差总是小于 0.5 ulp，那么该方法始终返回最接近准确结果的浮点数；这种方法就是正确舍入。 一个正确舍入的方法通常能得到最佳的浮点近似值；然而，对于许多浮点方法，进行正确舍入有些不切实际。 相反，对于 Math 类，某些方法允许误差在 1 或 2 ulp 的范围内。非正式地，对于 1 ulp 的误差范围， 当准确结果是可表示的数值时，应该按照计算结果返回准确结果；否则，返回包括准确结果的两个浮点值中的一个。 对于值很大的准确结果，括号的一端可以是无穷大。除了个别参数的准确性之外，维护不同参数的方法之间的正确关系也很重要。 因此，大多数误差大于 0.5 ulp 的方法都要求是半单调的：只要数学函数是非递减的，浮点近似值就是非递减的； 同样，只要数学函数是非递增的，浮点近似值就是非递增的。并非所有准确性为 1 ulp 的近似值都能自动满足单调性要求。 从以下版本开始： JDK1.0 字段摘要 static double E 比任何其他值都更接近 e（即自然对数的底数）的 double 值。 static double PI 比任何其他值都更接近 pi（即圆的周长与直径之比）的 double 值。 ceil(double a) 返回最小的（最接近负无穷大）double 值，该值大于等于参数，并等于某个整数。 floor(double a) 返回最大的（最接近正无穷大）double 值，该值小于等于参数，并等于某个整数。 rint(double a) 返回最接近参数并等于某一整数的 double 值。如果两个同为整数，且同样接近，则结果取偶数 static long round(double a) 返回最接近参数的 long。 将参数加上0.5后返回与参数最近的整数，然后强制转换为长整形 static int round(float a) 返回最接近参数的 int。 将参数加上0.5后返回与参数最近的整数 max(double a, double b) 返回两个 double 值中较大的一个。 static float max(float a, float b) 返回两个 float 值中较大的一个。 static int max(int a, int b) 返回两个 int 值中较大的一个。 static long max(long a, long b) 返回两个 long 值中较大的一个。 static double min(double a, double b) 返回两个 double 值中较小的一个。 static float min(float a, float b) 返回两个 float 值中较小的一个。 static int min(int a, int b) 返回两个 int 值中较小的一个。 static long min(long a, long b) 返回两个 long 值中较小的一个。 abs(double a) 返回 double 值的绝对值。 static float abs(float a) 返回 float 值的绝对值。 static int abs(int a) 返回 int 值的绝对值。 static long abs(long a) 返回 long 值的绝对值。 static double random() 返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。 即0<=Math.random()<1.0,虽然Math.random() 方法只能产生0-1之间的double型数字，但只要在Math.random（）语句上稍加处理，就可以使用这个方法产生任意范围的随机数， (int)(Math.random()*n)-------->返回大于等于0小于n的随机数 m+(int)(Math.random()*n)------>返回大于等于m小于m+n(不包括m+n)的随机数 (char)('a'+Math.random()*('z'-'a'+1))----->生成a-z之间的字符 (char)('A'+Math.random()*('Z'-'A'+1))----->生成A-Z之间的字符 random()方法返回的值实际上是伪随机数，他通过复杂的运算而得到一系列的数。 该方法是通过当前时间作为随机数生成器的参数，所以每次执行程序都会产生不同的随机数 */ public class MathDemo { //取绝对值 public static void absoluteMath(int i,float f,long l,double d){ //取int类型的绝对值 i = Math.abs(i); //取float类型的绝对值 f = Math.abs(f); //取double类型的绝对值 d = Math.abs(d); //取long类型的绝对值 l = Math.abs(l); System.out.println("取int类型的绝对值"+i); System.out.println("取double类型的绝对值"+d); System.out.println("取float类型的绝对值"+f); System.out.println("取long类型的绝对值"+l); } //取最值 public static void maximumMath(double a,double b,float c,float d,int e,int f,long h,long i){ //两个double类型的最大值 double maxD = Math.max(a, b); //两个double类型的最小值 double minD = Math.min(a, b); //两个float类型的最大值 float maxF = Math.max(c, d); //两个float类型的最小值 float minF = Math.min(c, d); //两个int类型的最大值 int maxI = Math.max(e, f); //两个int类型的最小值 int minI = Math.min(e, f); //两个long类型的最大值 long maxL = Math.max(h, i); //两个long类型的最小值 long minL = Math.min(h, i); System.out.println("两个double类型的最大值和最小值分别为："+maxD+minD); System.out.println("两个float类型的最大值和最小值分别为："+maxF+minF); System.out.println("两个int类型的最大值和最小值分别为："+maxI+minI); System.out.println("两个long类型的最大值和最小值分别为："+maxL+minL); } public static void nearestValueMath(double a,float b){ //最接近返回最小的（最接近负无穷大）double 值，该值大于等于参数，并等于某个整数。 double cD = Math.ceil(a); //返回最大的（最接近正无穷大）double 值，该值小于等于参数，并等于某个整数。 Double fD = Math.floor(a); //返回最接近参数并等于某一整数的 double 值。如果两个同为整数，且同样接近，则结果取偶数 double rD = Math.rint(a); // 返回最接近参数的 long。 将参数加上0.5后返回与参数最近的整数，然后强制转换为长整形 long rL = Math.round(a); //返回最接近参数的 int。 将参数加上0.5后返回与参数最近的整数 int rI = Math.round(b); System.out.println("最接近返回最小的（最接近负无穷大）double 值，该值大于等于参数，并等于某个整数。"+cD); System.out.println("返回最大的（最接近正无穷大）double 值，该值小于等于参数，并等于某个整数。"+fD); System.out.println("返回最接近参数并等于某一整数的 double 值。如果两个同为整数，且同样接近，则结果取偶数"+rD); System.out.println("返回最接近参数的 long。 将参数加上0.5后返回与参数最近的整数，然后强制转换为长整形"+rL); System.out.println("返回最接近参数的 int。 将参数加上0.5后返回与参数最近的整数"+rI); } //随机数 //获取a到b之间随机偶数 public static int getEvenNumber(double a,double b){ int s = (int)(a+Math.random()*(b-a)); if(s%2==0){ return s; }else return s+1; } //获取任意字符之间的随机字符 public static char randomCharMath(char ch1,char ch2){ return (char)(ch1+Math.random()*(ch2-ch1+1)); } //获取任意数字之间的随机数字,(包含任意两个数字) public static int randomNumberMath(int a,int b){ return (int)(a+Math.random()*(b-a+1)); } public static void main(String[] args) { // TODO Auto-generated method stub double a = 1.25; double b = 1.5; float c = -1.5f; float d = 3.21f; int e = 34; int f = -33; long h = -3123; long i = 67698; absoluteMath(f, c, h, b); maximumMath(a, b, c, d, e, f, h, i); nearestValueMath(b, c); //获取随机偶数 int even = getEvenNumber(1, 19); System.out.println("a到b的随机偶数为："+even); //获取随机字符 System.out.println("随机字符："+randomCharMath('a', 'z')); System.out.println("随机数字："+randomNumberMath(0, 9)); } }
Random
package you.demo.random; import java.util.Random; /* * Random: 创建随机数的类 * 在前面的Math类中我们看到其random()方法用于获取0-1（包括0不包括1）之间的随机数，我们通过一些操作， * 可以获取任意两个数、两个字符之间的任意值。在Java中还提供了一种用于获取随机数的方式，那就是java.util.Random类 * 可以通过实例化一个Random对象创建一个随机数生成器。 * 构造函数： * public Random() 创建 没有指定种子的 随机数对象,使用默认的种子， 当前时间的毫秒值 1秒 -- 1000毫秒 * public Random(long seed) 创建 指定种子的 随机数对象 如果使用的种子相同，得当的随机数也是相同 * 方法： * public int nextInt() : 获取int范围内的数据的随机数 * public int nextInt(int n) : 获取给定范围 [0,n) 内的 int随机数（包头不包尾） * public long nextLong():返回一个随机长整型值 * public boolean nextBoolean():返回一个随机布尔型值 * public float nextFloat():返回一个随机浮点型值 * public double nextDouble():返回一个随机双精度型值 * public double nextGaussian():返回一个概率密度为高斯分布的双精度值 */ public class RandomDemo { public static void main(String[] args) { // TODO Auto-generated method stub //实例化Random对象，创建一个随机数生成器 Random r1 = new Random();//使用默认的种子，以系统当前时间为默认种子 Random r2 = new Random(100);//设置随机数生成器的种子 System.out.println("获取int范围内的数据的随机数："+r1.nextInt()); System.out.println("获取int范围内的数据的随机数："+r2.nextInt()); System.out.println("获取0-10之间的任意数字："+r1.nextInt(10)); System.out.println("获取一个随机长整型数字："+r1.nextLong()); System.out.println("获取一个随机浮点数类型："+r1.nextFloat()); System.out.println("获取一个随机双精度浮点类型数字："+r1.nextDouble()); } }
BigInteger
package you.demo.bigdate; import java.math.BigInteger; /*在Java中提供了大数字的处理类，即java.math.BigInteger类与java.math.BigDecimal类。这两个类用于高精度 * 计算，常用于项目开发，其中BIgInteger针对大整数的处理类，而BigDecima则是针对大小数的处理类 * * BigInteger类型的数字范围较Integer类型数字范围要大得多，BIgInteger类用来处理更大的数字,BigInteger支持 * 任意精度的整数，即运算中BIgInteger类型可以准确的表示任何数字大小的整数值而不会丢失任何信息。 * * 字段摘要 static BigInteger ONE BigInteger 的常量 1。 static BigInteger TEN BigInteger 的常量 10。 static BigInteger ZERO BigInteger 的常量 0。 构造方法摘要 BigInteger(byte[] val) 将包含 BigInteger 的二进制补码表示形式的 byte 数组转换为 BigInteger。 BigInteger(int signum, byte[] magnitude) 将 BigInteger 的符号-数量表示形式转换为 BigInteger。 BigInteger(int bitLength, int certainty, Random rnd) 构造一个随机生成的正 BigInteger，它可能是一个具有指定 bitLength 的素数。 BigInteger(int numBits, Random rnd) 构造一个随机生成的 BigInteger，它是在 0 到 (2numBits - 1)（包括）范围内均匀分布的值。 BigInteger(String val) 将 BigInteger 的十进制字符串表示形式转换为 BigInteger。 BigInteger(String val, int radix) 将指定基数的 BigInteger 的字符串表示形式转换为 BigInteger。 方法摘要 BigInteger abs() 返回其值是此 BigInteger 的绝对值的 BigInteger。 BigInteger add(BigInteger val) 返回其值为 (this + val) 的 BigInteger。 BigInteger and(BigInteger val) 返回其值为 (this & val) 的 BigInteger。 int compareTo(BigInteger val) 将此 BigInteger 与指定的 BigInteger 进行比较。 BigInteger divide(BigInteger val) 返回其值为 (this / val) 的 BigInteger。 BigInteger[] divideAndRemainder(BigInteger val) 返回包含 (this / val) 后跟 (this % val) 的两个 BigInteger 的数组。 boolean equals(Object x) 比较此 BigInteger 与指定的 Object 的相等性。 当参数X是BigInteger类型的数字并且数值相等时，返回true BigInteger gcd(BigInteger val) 返回一个 BigInteger，其值是 abs(this) 和 abs(val) 的最大公约数。 int intValue() 将此 BigInteger 转换为 int。 long longValue() 将此 BigInteger 转换为 long。 BigInteger max(BigInteger val) 返回此 BigInteger 和 val 的最大值。 BigInteger min(BigInteger val) 返回此 BigInteger 和 val 的最小值。 BigInteger mod(BigInteger m) 返回其值为 (this mod m) 的 BigInteger。 BigInteger modInverse(BigInteger m) 返回其值为 (this-1 mod m) 的 BigInteger。 BigInteger modPow(BigInteger exponent, BigInteger m) 返回其值为 (thisexponent mod m) 的 BigInteger。 BigInteger multiply(BigInteger val) 返回其值为 (this * val) 的 BigInteger。 BigInteger negate() 返回其值是 (-this) 的 BigInteger。 BigInteger or(BigInteger val) 返回其值为 (this | val) 的 BigInteger。 BigInteger pow(int exponent) 返回其值为 (thisexponent) 的 BigInteger。 进行取参数的exponent次方操作 BigInteger remainder(BigInteger val) 返回其值为 (this % val) 的 BigInteger。 BigInteger shiftLeft(int n) 返回其值为 (this << n) 的 BigInteger。 BigInteger shiftRight(int n) 返回其值为 (this >> n) 的 BigInteger。 BigInteger subtract(BigInteger val) 返回其值为 (this - val) 的 BigInteger。 byte[] toByteArray() 返回一个 byte 数组，该数组包含此 BigInteger 的二进制补码表示形式。 String toString() 返回此 BigInteger 的十进制字符串表示形式。 String toString(int radix) 返回此 BigInteger 的给定基数的字符串表示形式。 */ public class BigIntegerDemo { public static void main(String[] args) { // TODO Auto-generated method stub //实例化大数字 BigInteger bi = new BigInteger("4736472649"); //该大数字加2的操作 System.out.println("该大数字加2的操作:"+bi.add(new BigInteger("2"))); //该大数字减2的操作 System.out.println("该大数字减2的操作:"+bi.subtract(new BigInteger("2"))); //该大数字乘以2的操作 System.out.println("该大数字乘以2的操作:"+bi.multiply(new BigInteger("2"))); //该大数字除以2的操作 System.out.println("该大数字除以2的操作:"+bi.divide(new BigInteger("2"))); //该大数字除以3的商 System.out.println("该大数字除以3的商:"+bi.divideAndRemainder(new BigInteger("3"))[0]); //该大数字除以3对的余数 System.out.println("该大数字除以3对的余数:"+bi.divideAndRemainder(new BigInteger("3"))[1]); //取该大数字的3次方 System.out.println("取该大数字的2次方:"+bi.pow(3)); //取该大数字的相反数 System.out.println("取该大数字的相反数:"+bi.negate()); //对该大数字取反再取绝对值 System.out.println("对该大数字取反再取绝对值:"+bi.negate().abs()); //做位与操作 System.out.println(bi.and(new BigInteger("1212312"))); //取最大值 System.out.println("取两个BIgInteger的最大值："+bi.max(new BigInteger("312415412"))); //取最小值 System.out.println("取两个BIgInteger的最小值："+bi.max(new BigInteger("312415412"))); //将此BIgInteger转换为String System.out.println("将此BIgInteger转换为String:"+bi.toString()); } }
BigDecimal
package you.demo.bigdate; import java.math.BigDecimal; /*BigDecimal类支持任何精度的定点数，可以用它来精确计算货币值 * * 字段摘要 static BigDecimal ONE 值为 1，标度为 0。 static int ROUND_CEILING 接近正无穷大的舍入模式。 static int ROUND_DOWN 接近零的舍入模式。 static int ROUND_FLOOR 接近负无穷大的舍入模式。 static int ROUND_HALF_DOWN 向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则为上舍入的舍入模式。 static int ROUND_HALF_EVEN 向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则向相邻的偶数舍入。 static int ROUND_HALF_UP 向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则为向上舍入的舍入模式。 static int ROUND_UNNECESSARY 断言请求的操作具有精确的结果，因此不需要舍入。 static int ROUND_UP 舍入远离零的舍入模式。 static BigDecimal TEN 值为 10，标度为 0。 static BigDecimal ZERO 值为 0，标度为 0。 构造方法 BigDecimal(BigInteger val) 将 BigInteger 转换为 BigDecimal。 BigDecimal(double val) 将 double 转换为 BigDecimal，后者是 double 的二进制浮点值准确的十进制表示形式。 BigDecimal(int val) 将 int 转换为 BigDecimal。 BigDecimal(String val) 将 BigDecimal 的字符串表示形式转换为 BigDecimal。 常用方法 abs() 返回 BigDecimal，其值为此 BigDecimal 的绝对值，其标度为 this.scale()。 BigDecimal add(BigDecimal augend) 返回一个 BigDecimal，其值为 (this + augend)，其标度为 max(this.scale(), augend.scale())。 divide(BigDecimal divisor) 返回一个 BigDecimal，其值为 (this / divisor)，其首选标度为 (this.scale() - divisor.scale())；如果无法表示准确的商值（因为它有无穷的十进制扩展），则抛出 ArithmeticException。 divide(BigDecimal divisor, int scale, int roundingMode) 返回一个 BigDecimal，其值为 (this / divisor)，其标度为指定标度。三个参数分别代表除数、商的小数点后的位数、近似处理模式 multiply(BigDecimal multiplicand) 返回一个 BigDecimal，其值为 (this × multiplicand)，其标度为 (this.scale() + multiplicand.scale())。 BigDecimal subtract(BigDecimal subtrahend) 返回一个 BigDecimal，其值为 (this - subtrahend)，其标度为 max(this.scale(), subtrahend.scale())。 */ public class BigDecimalDemo { /** * 定义加法方法，参数为加数和被加数 * @param value1 第一个参数 加数 * @param value2 第二个参数 被加数 * @param return 两数之和 */ public static BigDecimal add(double value1,double value2){ BigDecimal bd1 = new BigDecimal(Double.toString(value1)); BigDecimal bd2 = new BigDecimal(Double.toString(value2)); return bd1.add(bd2); } /** * 定义减法方法，参数为减数和被减数 * @param value1 第一个参数 减数 * @param value2 第二个参数 被减数 * @param return 两数相减之差 */ public static BigDecimal sub(double value1,double value2){ BigDecimal bd1 = new BigDecimal(Double.toString(value1)); BigDecimal bd2 = new BigDecimal(Double.toString(value2)); return bd1.subtract(bd2); } /** * 定义乘法方法，参数为乘数和被乘数 * @param value1 第一个参数 乘数 * @param value2 第二个参数 被乘数 * @param return 返回两数相乘的积 */ public static BigDecimal mul(double value1,double value2){ BigDecimal bd1 = new BigDecimal(Double.toString(value1)); BigDecimal bd2 = new BigDecimal(Double.toString(value2)); return bd1.multiply(bd2); } /** * 定义除法方法，参数为除数和被除数 * @param value1 第一个参数 除数 * @param value2 第二个参数 被除数 * @param i 第三个参数 小数点后保留的位数 * @param return * @param args */ public static BigDecimal div(double value1,double value2,int i){ //new BigDecimal(Double dou)会损失精度，所以我们一般将double转换成String，然后new BigDecimal(String str) // BigDecimal bd1 = new BigDecimal(value1); // BigDecimal bd2 = new BigDecimal(value2); BigDecimal bd1 = new BigDecimal(Double.toString(value1)); BigDecimal bd2 = new BigDecimal(Double.toString(value2)); //小数点保留2位，四舍五入模式 return bd1.divide(bd2, i, BigDecimal.ROUND_HALF_UP); } public static void main(String[] args) { System.out.println("两个BigDecimal数字相加的结果为："+add(234.7, 213.7)); System.out.println("两个BigDecimal数字相减的结果为："+sub(2312.989709, 1231.6329128)); System.out.println("两个BigDecimal数字相乘的结果为："+mul(6567.908908,2.0989907070)); System.out.println("两个BigDecimal数字相除的结果为："+div(67.90979869, 23.213871, 2)); } }
System
package you.demo.system; import java.util.Arrays; /* * System: 系统类 * * 需要掌握的方法： * public static void gc() 垃圾回收器 (回收垃圾对象) * public static void exit(int status) 终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非 0 的状态码表示异常终止。 * System.exit(0);//正常结束程序 * public static long currentTimeMillis() : 返回当前时间的毫秒值 * public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length) * 从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束 * src - 源数组。 * srcPos - 源数组中的起始位置。 * dest - 目标数组。 * destPos - 目标数据中的起始位置。 注意脚标越界异常 * length - 要复制的数组元素的数量。 */ public class SystemDemo { public static void main(String[] args) { // TODO Auto-generated method stub Long timeStart = System.currentTimeMillis(); for (int i = 0; i < 10000; i++) { String str = "a"; str+=str; } Long timeEnd = System.currentTimeMillis(); System.out.println("返回当前时间的毫秒值："+(timeEnd-timeStart)); int[] src ={0,1,2,3}; int[] dest ={2,3,4,5,8}; arrSystem(src, dest); SystemDemo sd = new SystemDemo(); System.gc();//垃圾回收机制，只有当内存紧张才会清楚垃圾，哪怕调用也没有意义 sd.test(); System.exit(0);//正常结束Java虚拟机 sd.test(); } //测试方法 public static void test(){ System.out.println("测试方法！"); } //数组复制 /* public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length) * 从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束 * src - 源数组。 * srcPos - 源数组中的起始位置。 * dest - 目标数组。 * destPos - 目标数据中的起始位置。 * length - 要复制的数组元素的数量。 */ public static void arrSystem(int[] src,int[] dest){ //错误情况 //ArrayIndexOutOfBoundsException //System.arraycopy(src, 3, dest, 3, 5); //数组长度一经设置不可改变，所以，destPos+lendgh<=dest.lendgh() System.arraycopy(src, 0, dest, 2, 1); System.out.println(Arrays.toString(src)); System.out.println(Arrays.toString(dest)); } }
Date
package you.demo.dateformat; import java.util.Date; /*类 Date 表示特定的瞬间，精确到毫秒。 在 JDK 1.1 之前，类 Date 有两个其他的函数。它允许把日期解释为年、月、日、小时、分钟和秒值。 它也允许格式化和解析日期字符串。不过，这些函数的 API 不易于实现国际化。从 JDK 1.1 开始， 应该使用 Calendar 类实现日期和时间字段之间转换，使用 DateFormat 类来格式化和解析日期字符串。 Date 中的相应方法已废弃。 尽管 Date 类打算反映协调世界时 (UTC)，但无法做到如此准确，这取决于 Java 虚拟机的主机环境。 当前几乎所有操作系统都假定 1 天 = 24 × 60 × 60 = 86400 秒。但对于 UTC，大约每一两年出现一次额外的一秒， 称为“闰秒”。闰秒始终作为当天的最后一秒增加，并且始终在 12 月 31 日或 6 月 30 日增加。 例如，1995 年的最后一分钟是 61 秒，因为增加了闰秒。大多数计算机时钟不是特别的准确，因此不能反映闰秒的差别。 在类 Date 所有可以接受或返回年、月、日期、小时、分钟和秒值的方法中，将使用下面的表示形式： 年份 y 由整数 y - 1900 表示。 月份由从 0 至 11 的整数表示；0 是一月、1 是二月等等；因此 11 是十二月。 日期（一月中的某天）按通常方式由整数 1 至 31 表示。 小时由从 0 至 23 的整数表示。因此，从午夜到 1 a.m. 的时间是 0 点，从中午到 1 p.m. 的时间是 12 点。 分钟按通常方式由 0 至 59 的整数表示。 秒由 0 至 61 的整数表示；值 60 和 61 只对闰秒发生，尽管那样，也只用在实际正确跟踪闰秒的 Java 实现中。于按当前引入闰秒的方式， 两个闰秒在同一分钟内发生是极不可能的，但此规范遵循 ISO C 的日期和时间约定。 在所有情形中， 针对这些目的赋予方法的参数不需要在指定的范围内；例如，可以把日期指定为 1 月 32 日， 并把它解释为 2 月 1 日的相同含义。 从以下版本开始： JDK1.0 构造方法摘要 Date() 分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。 Date(long date) 分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。 方法摘要 boolean after(Date when) 测试此日期是否在指定日期之后。 boolean before(Date when) 测试此日期是否在指定日期之前。 Object clone() 返回此对象的副本。 int compareTo(Date anotherDate) 比较两个日期的顺序。 boolean equals(Object obj) 比较两个日期的相等性。 Date类要掌握的功能 * 毫秒到日期的转换 * public Date(long date) * 日期到毫秒的转换 * public long getTime() * */ public class DateDemo { //声明一个公共静态成员变量，作为一个指定日期 public static Date d = new Date(10000000000L); //测试此日期是否在指定日期之后 public static boolean after(long da){ Date dd = new Date(da); System.out.println(dd); return dd.after(d); } //测试此日期是否在指定日期之前 public static boolean before(long da){ //毫秒到日期的转换 Date dd = new Date(da); System.out.println(dd); return dd.before(d); } //比较两个日期的顺序 public static int compare(long l1,long l2){ Date d1 = new Date(l1); Date d2 = new Date(l2); System.out.println("d1的时间为："+d1+",d2的时间为："+d2); //d1如果时间比d2早返回int型-1，d1如果比d2晚返回int型1 return d1.compareTo(d2); } //比较两个日期的相等性 public static boolean equ(long l1,long l2){ Date d1 = new Date(l1); Date d2 = new Date(l2); return d1.equals(d2); } //返回此对象副本 public static Object object(long l){ return new Date(l).clone(); } //将当前时间转换为毫秒值 public static long change(Date d){ return d.getTime(); } // public static void main(String[] args) { // TODO Auto-generated method stub System.out.println(d); System.out.println("判断此时间是否在指定时间之后："+after(10000000L)); System.out.println("判断此时间是否在指定时间之前："+before(10000000L)); System.out.println("判断两个时间的顺序："+compare(100000000L, 10000005L)); System.out.println("判断两个时间是否相等："+equ(1000005L, 1000004L)); System.out.println("返回此对象副本："+object(100000L)); System.out.println("将当前时间转换为毫秒值："+change(new Date(123456789L))); System.out.println("获取当前时间："+new Date());
//下面方法已过时
System.out.println(d.getDate());
System.out.println(d.getDay());
System.out.println(d.getHours());
System.out.println(d.getMinutes());
System.out.println(d.getMonth());
System.out.println(d.getSeconds());
System.out.println(d.getYear());
}
}
DateFormat
package you.demo.dateformat; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; /* * DateFormat: 日期格式化类, 用来进行日期格式约束的 * DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。 * 日期/时间格式化子类（如 SimpleDateFormat）允许进行格式化（也就是日期 -> 文本）、解析（文本-> 日期）和标准化。 * 将日期表示为 Date 对象，或者表示为从 GMT（格林尼治标准时间）1970 年 1 月 1 日 00:00:00 这一刻开始的毫秒数。 * * 发现它是一个抽象类，不能创建对象，所以，使用子类来创建对象 SimpleDateFormat * * java.lang.Object java.text.Format java.text.DateFormat java.text.SimpleDateFormat SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。 它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。 SimpleDateFormat 使得可以选择任何用户定义的日期-时间格式的模式。 但是，仍然建议通过 DateFormat 中的 getTimeInstance、getDateInstance 或 getDateTimeInstance 来创建日期-时间格式器。 每一个这样的类方法都能够返回一个以默认格式模式初始化的日期/时间格式器。 可以根据需要使用 applyPattern 方法来修改格式模式。有关使用这些方法的更多信息，请参阅 DateFormat。 日期和时间模式 日期和时间格式由日期和时间模式 字符串指定。在日期和时间模式字符串中，未加引号的字母 'A' 到 'Z' 和 'a' 到 'z' 被解释为模式字母，用来表示日期或时间字符串元素。文本可以使用单引号 (') 引起来，以免进行解释。"''" 表示单引号。 所有其他字符均不解释；只是在格式化时将它们简单复制到输出字符串，或者在解析时与输入字符串进行匹配。 定义了以下模式字母（所有其他字符 'A' 到 'Z' 和 'a' 到 'z' 都被保留）： 字母 日期或时间元素 表示 示例 G Era 标志符 Text AD y 年 Year 1996; 96 M 年中的月份 Month July; Jul; 07 w 年中的周数 Number 27 W 月份中的周数 Number 2 D 年中的天数 Number 189 d 月份中的天数 Number 10 F 月份中的星期 Number 2 E 星期中的天数 Text Tuesday; Tue a Am/pm 标记 Text PM H 一天中的小时数（0-23） Number 0 k 一天中的小时数（1-24） Number 24 K am/pm 中的小时数（0-11） Number 0 h am/pm 中的小时数（1-12） Number 12 m 小时中的分钟数 Number 30 s 分钟中的秒数 Number 55 S 毫秒数 Number 978 z 时区 General time zone Pacific Standard Time; PST; GMT-08:00 Z 时区 RFC 822 time zone -0800 * SimpleDateFormat * 构造函数： * 2014-06-15 10:21:44 * public SimpleDateFormat() ： 使用默认样式，进行日期格式化 * public SimpleDateFormat(String pattern) : 使用给定的样式，进行日期格式化 * * DateFormat要掌握的功能 * 从日期到字符串的转换 * public final String format(Date date) * 从字符串到日期的转换 * public Date parse(String source) * StringBuffer format(Date date, StringBuffer toAppendTo, FieldPosition pos) 将给定的 Date 格式化为日期/时间字符串，并将结果添加到给定的 StringBuffer。 * Date parse(String text, ParsePosition pos) 解析字符串的文本，生成 Date。 */ public class DateFormatDemo { public static void main(String[] args) throws ParseException { //从日期到字符串的转换 dateToString(); //从字符串到日期的转换 stringToDate(); //使用给定的模式，从日期到字符串转换 dateToStringA(); stringToDateA(); } //从日期到字符串转换 public static void dateToString(){ Date dd = new Date(); //使用默认样式进行日期格式化 SimpleDateFormat sdf = new SimpleDateFormat(); String str = sdf.format(dd); System.out.println("日期格式化后的字符串显示："+str); } //从字符串到日期的转换 public static void stringToDate() throws ParseException{ //定义一个 日期字符串 String time = "2001-07-04 12:08:56"; SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); Date dd = sdf.parse(time); System.out.println("从字符串到日期的转换："+dd); } //使用给定的模式，从日期到字符串转换 public static void dateToStringA(){ //创建日期对象 Date dd = new Date(); //使用给定模式，创建日期格式化对象 SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS"); SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd"); String str1 = sdf1.format(dd); String str2 = sdf2.format(dd); System.out.println("按照格式格式化日期，将日期转换为字符串："+str1); System.out.println("按照格式格式化日期，将日期转换为字符串："+str2); } //使用给定的格式格式化时间，将时间转换为字符串，将字符串转换为时间 public static void stringToDateA(){ Date dd = new Date(); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); String str = sdf.format(dd); try { dd = sdf.parse(str); } catch (ParseException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println("打印时间："+dd); } }
Calendar
package you.demo.calendar; import java.util.Calendar; /* * Calendar： 日历类 抽象类不能通过new实例化对象 * * 字段摘要 static int ALL_STYLES 指示所有风格名称的 getDisplayNames 的风格说明符，比如 "January" 和 "Jan"。 static int AM 指示从午夜到中午之前这段时间的 AM_PM 字段值。 static int AM_PM get 和 set 的字段数字，指示 HOUR 是在中午之前还是在中午之后。 static int APRIL 指示在格里高利历和罗马儒略历中一年中第四个月的 MONTH 字段值。 protected boolean areFieldsSet 如果 fields[] 与当前的设置时间同步，则返回 true。 static int AUGUST 指示在格里高利历和罗马儒略历中一年中第八个月的 MONTH 字段值。 static int DATE get 和 set 的字段数字，指示一个月中的某天。 static int DAY_OF_MONTH get 和 set 的字段数字，指示一个月中的某天。 static int DAY_OF_WEEK get 和 set 的字段数字，指示一个星期中的某天。 static int DAY_OF_WEEK_IN_MONTH get 和 set 的字段数字，指示当前月中的第几个星期。 static int DAY_OF_YEAR get 和 set 的字段数字，指示当前年中的天数。 static int DECEMBER 指示在格里高利历和罗马儒略历中一年中第十二个月的 MONTH 字段值。 static int DST_OFFSET get 和 set 的字段数字，以毫秒为单位指示夏令时的偏移量。 static int ERA 指示年代的 get 和 set 的字段数字，比如罗马儒略历中的 AD 或 BC。 static int FEBRUARY 指示在格里高利历和罗马儒略历中一年中第二个月的 MONTH 字段值。 static int FIELD_COUNT get 和 set 可识别的不同字段的数量。 protected int[] fields 此日历当前设置时间的日历字段值。 static int FRIDAY 指示 Friday 的 DAY_OF_WEEK 字段值。 static int HOUR get 和 set 的字段数字，指示上午或下午的小时。 static int HOUR_OF_DAY get 和 set 的字段数字，指示一天中的小时。 protected boolean[] isSet 通知是否设置了该日历某一指定日历字段的标志。 protected boolean isTimeSet 如果 time 值是一个有效值，则返回 true。 static int JANUARY 指示在格里高利历和罗马儒略历中一年中第一个月的 MONTH 字段值。 static int JULY 指示在格里高利历和罗马儒略历中一年中第七个月的 MONTH 字段值。 static int JUNE 指示在格里高利历和罗马儒略历中一年中第六个月的 MONTH 字段值。 static int LONG 指示长名称的 getDisplayName 和 getDisplayNames 的风格说明符，比如 "January"。 static int MARCH 指示在格里高利历和罗马儒略历中一年中第三个月的 MONTH 字段值。 static int MAY 指示在格里高利历和罗马儒略历中一年中第五个月的 MONTH 字段值。 static int MILLISECOND get 和 set 的字段数字，指示一秒中的毫秒。 static int MINUTE get 和 set 的字段数字，指示一小时中的分钟。 static int MONDAY 指示 Monday 的 DAY_OF_WEEK 字段值。 static int MONTH 指示月份的 get 和 set 的字段数字。 static int NOVEMBER 指示在格里高利历和罗马儒略历中一年中第十一个月的 MONTH 字段值。 static int OCTOBER 指示在格里高利历和罗马儒略历中一年中第十个月的 MONTH 字段值。 static int PM 指示从中午到午夜之前这段时间的 AM_PM 字段值。 static int SATURDAY 指示 Saturday 的 DAY_OF_WEEK 字段值。 static int SECOND get 和 set 的字段数字，指示一分钟中的秒。 static int SEPTEMBER 指示在格里高利历和罗马儒略历中一年中第九个月的 MONTH 字段值。 static int SHORT 指示短名称的 getDisplayName 和 getDisplayNames 的风格说明符，比如 "Jan"。 static int SUNDAY 指示 Sunday 的 DAY_OF_WEEK 字段值。 static int THURSDAY 指示 Thursday 的 DAY_OF_WEEK 字段值。 protected long time 日历的当前设置时间，以毫秒为单位，表示自格林威治标准时间 1970 年 1月 1 日 0:00:00 后经过的时间。 static int TUESDAY 指示 Tuesday 的 DAY_OF_WEEK 字段值。 static int UNDECIMBER 指示一年中第十三个月的 MONTH 字段值。 static int WEDNESDAY 指示 Wednesday 的 DAY_OF_WEEK 字段值。 static int WEEK_OF_MONTH get 和 set 的字段数字，指示当前月中的星期数。 static int WEEK_OF_YEAR get 和 set 的字段数字，指示当前年中的星期数。 static int YEAR 指示年的 get 和 set 的字段数字。 static int ZONE_OFFSET get 和 set 的字段数字，以毫秒为单位指示距 GMT 的大致偏移量。 * 方法： * public static Calendar getInstance() ： 获取一个日历类 实例化对象 * * public int get(int field) : 返回给定日历字段的值 * public final void set(int year,int month, int date) : 设置年月日等信息 * public abstract void add(int field, int amount) : 为给定的日历字段添加或减去指定的时间量。 */ public class CalendarDemo { public static void main(String[] args) { // 获取日历对象 Calendar ca = Calendar.getInstance(); System.out.println("返回给定日历字段的值-年份："+ca.get(Calendar.YEAR)); System.out.println("返回给定日历字段的值-月份"+ca.get(Calendar.MONTH));//月份是从0-11,0代表1月 System.out.println("返回给定日历字段的值-天"+ca.get(Calendar.DATE)); System.out.println("返回给定日历字段的值-小时"+ca.get(Calendar.HOUR)); } }
