标签：ott idt svn header 参数 svc val turn foo
1. Scanner类
java.util.Scanner 是 Java5 的新特征，我们可以通过 Scanner 类来获取用户的输入。
Scanner s = new Scanner(System.in);
import java.util.Scanner;
public class ScannerDemo {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
// 从键盘接收数据
//next方式接收字符串
System.out.println("next方式接收：");
// 判断是否还有输入
if(scan.hasNext()){
String str1 = scan.next();
System.out.println("输入的数据为："+str1);
}
}
}
输出结果：
$ javac ScannerDemo.java
$ java ScannerDemo
next方式接收：
rimi com
输入的数据为：rimi
可以看到 com 字符串并未输出
import java.util.Scanner;
public class ScannerDemo {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
// 从键盘接收数据
//nextLine方式接收字符串
System.out.println("nextLine方式接收：");
// 判断是否还有输入
if(scan.hasNextLine()){
String str2 = scan.nextLine();
System.out.println("输入的数据为："+str2);
}
}
}
执行以上程序输出结果为：
$ javac ScannerDemo.java
$ java ScannerDemo
nextLine方式接收：
rimi com
输入的数据为：rimi com
可以看到 com 字符串输出。
next():
1、一定要读取到有效字符后才可以结束输入。
2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
4、next() 不能得到带有空格的字符串。
nextLine()：
1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
2、可以获得空白。
如果要输入 int 或 float 类型的数据，在 Scanner 类中也有支持，但是在输入之前最好先使用 hasNextXxx() 方法进行验证，再使用 nextXxx() 来读取
import java.util.Scanner;
public class ScannerDemo {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
// 从键盘接收数据
int i = 0 ;
float f = 0.0f ;
System.out.print("输入整数：");
if(scan.hasNextInt()){
// 判断输入的是否是整数
i = scan.nextInt() ;
// 接收整数
System.out.println("整数数据：" + i) ;
}else{
// 输入错误的信息
System.out.println("输入的不是整数！") ;
}
System.out.print("输入小数：");
if(scan.hasNextFloat()){
// 判断输入的是否是小数
f = scan.nextFloat() ;
// 接收小数
System.out.println("小数数据：" + f) ;
}else{
// 输入错误的信息
System.out.println("输入的不是小数！") ;
}
}
}
输出结果：
$ javac ScannerDemo.java
$ java ScannerDemo
输入整数：12
整数数据：12
输入小数：1.2
小数数据：1.2
1. 请输入需要累加的整数，直到输入 0 结束累加。
一般地，当需要使用数字的时候，我们通常使用内置数据类型，如：byte、int、long、double 等
int a = 5000;
float b = 13.65f;
byte c = 0x4a;
然而，在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问题，Java 语言为每一个内置数据类型提供了对应的包装类。
所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。
这种由编译器特别支持的包装称为装箱，所以当内置数据类型被当作对象使用的时候，编译器会把内置类型装箱为包装类。相似的，编译器也可以把一个对象拆箱为内置类型。Number 类属于 java.lang 包。
public class Test{
public static void main(String args[]){
Integer x = 5;
x = x + 10;
System.out.println(x);
}
}
当 x 被赋为整型值时，由于x是一个对象，所以编译器要对x进行装箱。然后，为了使x能进行加运算，所以要对x进行拆箱。
关于拆箱封箱
/**
*
* java中的自动装箱与拆箱
* 简单一点说，装箱就是自动将基本数据类型转换为包装器类型；拆箱就是自动将包装器类型转换为基本数据类型。
*/
public class NumberDemo {
public static void main(String[] args) {
/*
Integer i1 = 128; // 装箱，相当于 Integer.valueOf(128);
int t = i1; //相当于 i1.intValue() 拆箱
System.out.println(t);
*/
/*
对于–128到127（默认是127）之间的值,被装箱后，会被放在内存里进行重用
但是如果超出了这个值,系统会重新new 一个对象
*/
Integer i1 = 200;
Integer i2 = 200;
/*
注意 == 与 equals的区别
== 它比较的是对象的地址
equlas 比较的是对象的内容
*/
if(i1==i2) {
System.out.println("true");
} else {
System.out.println("false");
}
}
}
Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。
Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。
public class Test {
public static void main (String []args)
{
System.out.println("90 度的正弦值：" + Math.sin(Math.PI/2));
System.out.println("0度的余弦值：" + Math.cos(0));
System.out.println("60度的正切值：" + Math.tan(Math.PI/3));
System.out.println("1的反正切值： " + Math.atan(1));
System.out.println("π/2的角度值：" + Math.toDegrees(Math.PI/2));
System.out.println(Math.PI);
}
}
结果如下：
90 度的正弦值：1.0
0度的余弦值：1.0
60度的正切值：1.7320508075688767
1的反正切值： 0.7853981633974483
π/2的角度值：90.0
3.141592653589793
1 xxxValue()
将 Number 对象转换为xxx数据类型的值并返回。
2 compareTo()
将number对象与参数比较。
3 equals()
判断number对象是否与参数相等。
4 valueOf()
返回一个 Number 对象指定的内置数据类型
5 toString()
以字符串形式返回值。
6 parseInt()
将字符串解析为int类型。
7 abs()
返回参数的绝对值。
8 ceil()
对整形变量向左取整，返回类型为double型。
9 floor()
对整型变量向右取整。返回类型为double类型。
10 rint()
返回与参数最接近的整数。返回类型为double。
11 round()
返回一个最接近的int、long型值。
12 min()
返回两个参数中的最小值。
13 max()
返回两个参数中的最大值。
14 exp()
返回自然数底数e的参数次方。
15 log()
返回参数的自然数底数的对数值。
16 pow()
返回第一个参数的第二个参数次方。
17 sqrt()
求参数的算术平方根。
18 sin()
求指定double类型参数的正弦值。
19 cos()
求指定double类型参数的余弦值。
20 tan()
求指定double类型参数的正切值。
21 asin()
求指定double类型参数的反正弦值。
22 acos()
求指定double类型参数的反余弦值。
23 atan()
求指定double类型参数的反正切值。
24 atan2()
将笛卡尔坐标转换为极坐标，并返回极坐标的角度值。
25 toDegrees()
将参数转化为角度。
26 toRadians()
将角度转换为弧度。
27 random()
返回一个随机数。
举例
/**
* abs求绝对值
*/
System.out.println(Math.abs(-10.4)); //10.4
System.out.println(Math.abs(10.1)); //10.1
/**
* ceil天花板的意思，就是返回大的值，注意一些特殊值
*/
System.out.println(Math.ceil(-10.1)); //-10.0
System.out.println(Math.ceil(10.7)); //11.0
System.out.println(Math.ceil(-0.7)); //-0.0
System.out.println(Math.ceil(0.0)); //0.0
System.out.println(Math.ceil(-0.0)); //-0.0
/**
* floor地板的意思，就是返回小的值
*/
System.out.println(Math.floor(-10.1)); //-11.0
System.out.println(Math.floor(10.7)); //10.0
System.out.println(Math.floor(-0.7)); //-1.0
System.out.println(Math.floor(0.0)); //0.0
System.out.println(Math.floor(-0.0)); //-0.0
/**
* max 两个中返回大的值,min和它相反，就不举例了
*/
System.out.println(Math.max(-10.1, -10)); //-10.0
System.out.println(Math.max(10.7, 10)); //10.7
System.out.println(Math.max(0.0, -0.0)); //0.0
/**
* random 取得一个大于或者等于0.0小于不等于1.0的随机数
*/
System.out.println(Math.random()); //0.08417657924317234
System.out.println(Math.random()); //0.43527904004403717
/**
* rint 四舍五入，返回double值
* 注意.5的时候会取偶数
*/
System.out.println(Math.rint(10.1)); //10.0
System.out.println(Math.rint(10.7)); //11.0
System.out.println(Math.rint(11.5)); //12.0
System.out.println(Math.rint(10.5)); //10.0
System.out.println(Math.rint(10.51)); //11.0
System.out.println(Math.rint(-10.5)); //-10.0
System.out.println(Math.rint(-11.5)); //-12.0
System.out.println(Math.rint(-10.51)); //-11.0
System.out.println(Math.rint(-10.6)); //-11.0
System.out.println(Math.rint(-10.2)); //-10.0
/**
* round 四舍五入，float时返回int值，double时返回long值
*/
System.out.println(Math.round(10.1)); //10
System.out.println(Math.round(10.7)); //11
System.out.println(Math.round(10.5)); //11
System.out.println(Math.round(10.51)); //11
System.out.println(Math.round(-10.5)); //-10
System.out.println(Math.round(-10.51)); //-11
System.out.println(Math.round(-10.6)); //-11
System.out.println(Math.round(-10.2)); //-10
Character 类用于对单个字符进行操作。
Character 类在对象中包装一个基本类型 char 的值
// 单个字符
char ch = ‘a‘;
// Unicode 字符表示形式
char uniChar = ‘\u039A‘;
// 字符数组
char[] charArray ={ ‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘ };
// 包装类 Character
Character ch = new Character(‘a‘);
在某些情况下，Java编译器会自动创建一个Character对象。
例如，将一个char类型的参数传递给需要一个Character类型参数的方法时，那么编译器会自动地将char类型参数转换为Character对象。 这种特征称为装箱，反过来称为拆箱。
public static void main(String[] args) {
// 原始字符 ‘a‘ 装箱到 Character 对象 character 中
Character character = ‘a‘;
// 原始字符 ‘x‘ 用 test 方法装箱
// 返回拆箱的值到 ch
char ch = test(‘x‘);
}
public static char test(Character c) {
return c;
}
前面有反斜杠（\）的字符代表转义字符，它对编译器来说是有特殊含义的。
\t 在文中该处插入一个tab键
\b 在文中该处插入一个后退键
\n 在文中该处换行
\r 在文中该处插入回车
\f 在文中该处插入换页符
\‘ 在文中该处插入单引号
\" 在文中该处插入双引号
\\ 在文中该处插入反斜杠
1 isLetter() 是否是一个字母
2 isDigit() 是否是一个数字字符
3 isWhitespace() 是否是一个空格
4 isUpperCase() 是否是大写字母
5 isLowerCase() 是否是小写字母
6 toUpperCase() 指定字母的大写形式
7 toLowerCase() 指定字母的小写形式
8 toString() 返回字符的字符串形式，字符串的长度仅为1
字符串广泛应用 在Java 编程中，在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。
创建字符串最简单的方式如下:
String greeting = "睿峰科技";
在代码中遇到字符串常量时，这里的值是 "睿峰科技""，编译器会使用该值创建一个 String 对象。 和其它对象一样，可以使用关键字和构造方法来创建 String 对象。 String 类有 11 种构造方法，这些方法提供不同的参数来初始化字符串，比如提供一个字符数组参数:
public class StringDemo{
public static void main(String args[]){
char[] nameArray = { ‘r‘, ‘i‘, ‘m‘, ‘i‘};
String nameString = new String(nameArray);
System.out.println(nameString);
}
}
注意:String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了。
如果需要对字符串做很多修改，那么应该选择使用 StringBuffer & StringBuilder 类。
String 类是不可改变的解析，例如：
String s = "Google";
System.out.println("s = " + s);
s = "Rimi";
System.out.println("s = " + s);
结果为：
Google
Rimi
从结果上看是改变了，但为什么门说String对象是不可变的呢？
原因在于实例中的 s 只是一个 String 对象的引用，并不是对象本身，当执行 s = "Rimi"; 创建了一个新的对象 "Rimi"，而原来的 "Google" 还存在于内存中。
用于获取有关对象的信息的方法称为访问器方法。
String 类的一个访问器方法是 length() 方法，它返回字符串对象包含的字符数。
public class StringDemo {
public static void main(String args[]) {
String site = "www.rimiedu.com";
int len = site.length();
System.out.println( "睿峰教育网址长度 : " + len );
}
}
String 类提供了连接两个字符串的方法：
string1.concat(string2);
更常用的是使用‘+‘操作符来连接字符串，如：
"Hello," + " rimi" + "!"
1.字符串比较
compareTo
compareToIgnoreCase(//忽略大小写)
2.查找字符串最后一次出现的位置
lastIndexOf
3.截取字符串出现
substring
4.字符串替换
replace
replaceFirst
replaceAll
5.字符串反转
StringBuffer
6.字符串查找
indexOf
7.字符串分割
split
8.字符串小写转大写
toUpperCase
9.测试两个字符串区域是否相等
//参数说明：自己的起始位置，比较的 String, 比较的 String 的起始位置，比较长度。
regionMatches(11, second_str, 12, 9);
regionMatches(true, 11, second_str, 12, 9); //第一个参数 true 表示忽略大小写区别
10.字符串性能比较测试
System.currentTimeMillis(); //利用获取时间戳进行比较
//第一种创建形式
String s1 = "hello";
//第二种创建形式
String s2 = new String("hello");
11.字符串优化
1. 直接使用字符串
String str = "123";
String str1 = "123";
2. 使用 new 关键字
String str2 = new String("123");
12.连接字符串
字符串连接 - 使用 + 操作符
字符串连接 - 使用 StringBuffer/StringBuilder
StringBuffer
代码示例：
StringBuilder sb = new StringBuilder ( "" );
for ( int i= 0 ;i< 10 ;i++){
sb.append(String.valueOf(i));
System.out.println(sb+",");
}
当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。
和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。
StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。
public class Test{
public static void main(String args[]){
StringBuffer sBuffer = new StringBuffer("睿峰官网：");
sBuffer.append("www");
sBuffer.append(".rimi");
sBuffer.append(".com");
System.out.println(sBuffer);
}
}
StringBuffer方法：
1 public StringBuffer append(String s) 将指定的字符串追加到此字符序列。
2 public StringBuffer reverse() 将此字符序列用其反转形式取代。
3 public delete(int start, int end) 移除此序列的子字符串中的字符。
4 public insert(int offset, int i) 将 int 参数的字符串表示形式插入此序列中。
5 replace(int start, int end, String str) 使用给定 String 中的字符替换此序列的子字符串中的字符。
Java 中 StringBuffer 和 String 是有一定的区别的
首先，String 是被 final 修饰的，他的长度是不可变的，就算调用 String 的 concat 方法，那也是把字符串拼接起来并重新创建一个对象，把拼接后的 String 的值赋给新创建的对象，
而 StringBuffer 的长度是可变的，调用StringBuffer 的 append 方法，来改变 StringBuffer 的长度，并且，相比较于 StringBuffer，String 一旦发生长度变化，是非常耗费内存的！
java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。
具有以下功能：
常用方法：
1 public static int binarySearch(Object[] a, Object key)
用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
2 public static boolean equals(long[] a, long[] a2)
如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
3 public static void fill(int[] a, int val)
将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
4 public static void sort(Object[] a)
对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
java.util 包提供了 Date 类来封装当前的日期和时间。 Date 类提供两个构造函数来实例化 Date 对象。
第一个构造函数使用当前日期和时间来初始化对象。
Date( )
第二个构造函数接收一个参数，该参数是从1970年1月1日起的毫秒数。
Date(long millisec)
1 boolean after(Date date)
若当调用此方法的Date对象在指定日期之后返回true,否则返回false。
2 boolean before(Date date)
若当调用此方法的Date对象在指定日期之前返回true,否则返回false。
3 Object clone( )
返回此对象的副本。
4 int compareTo(Date date)
比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。
5 int compareTo(Object obj)
若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。
6 boolean equals(Object date)
当调用此方法的Date对象和指定日期相等时候返回true,否则返回false。
7 long getTime( )
返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
8 int hashCode( )
返回此对象的哈希码值。
9 void setTime(long time)
用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。
10 String toString( )
转换Date对象为String表示形式，并返回该字符串。
Java中获取当前日期和时间很简单，使用 Date 对象的 toString() 方法来打印当前日期和时间
import java.util.Date;
public class DateDemo {
public static void main(String args[]) {
// 初始化 Date 对象
Date date = new Date();
// 使用 toString() 函数显示日期时间
System.out.println(date.toString());
}
}
Java使用以下三种方法来比较两个日期：
SimpleDateFormat 是一个以语言环境敏感的方式来格式化和分析日期的类。SimpleDateFormat 允许你选择任何用户自定义日期时间格式来运行
import java.util.*;
import java.text.*;
public class DateDemo {
public static void main(String args[]) {
Date dNow = new Date( );
SimpleDateFormat ft = new SimpleDateFormat ("E yyyy.MM.dd ‘at‘ hh:mm:ss a zzz");
System.out.println("Current Date: " + ft.format(dNow));
}
}
这一行代码确立了转换的格式，其中 yyyy 是完整的公元年，MM 是月份，dd 是日期，HH:mm:ss 是时、分、秒。
注意:有的格式大写，有的格式小写，例如 MM 是月份，mm 是分；HH 是 24 小时制，而 hh 是 12 小时制。
时间模式字符串用来指定时间格式。在此模式中，所有的 ASCII 字母被保留为模式字母，定义如下：
G 纪元标记 AD
y 四位年份 2001
M 月份 July or 07
d 一个月的日期 10
h A.M./P.M. (1~12)格式小时 12
H 一天中的小时 (0~23) 22
m 分钟数 30
s 秒数 55
S 毫秒数 234
E 星期几 Tuesday
D 一年中的日子 360
F 一个月中第几周的周几 2 (second Wed. in July)
w 一年中第几周 40
W 一个月中第几周 1
a A.M./P.M. 标记 PM
k 一天中的小时(1~24) 24
K A.M./P.M. (0~11)格式小时 10
z 时区 Eastern Standard Time
‘ 文字定界符 Delimiter
" 单引号 `
System.currentTimeMillis(); //获取当前时间戳
import java.util.*;
public class DiffDemo {
public static void main(String args[]) {
try {
long start = System.currentTimeMillis( );
System.out.println(new Date( ) + "\n");
Thread.sleep(5*60*10);
System.out.println(new Date( ) + "\n");
long end = System.currentTimeMillis( );
long diff = end - start;
System.out.println("Difference is : " + diff);
} catch (Exception e) {
System.out.println("Got an exception!");
}
}
}
我们现在已经能够格式化并创建一个日期对象了，但是我们如何才能设置和获取日期数据的特定部分呢，比如说小时，日，或者分钟? 我们又如何在日期的这些部分加上或者减去值呢? 答案是使用Calendar 类。
Calendar类的功能要比Date类强大很多，而且在实现方式上也比Date类要复杂一些。
Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建对象的过程对程序员来说是透明的，只需要使用getInstance方法创建即可。
创建一个代表系统当前日期的Calendar对象
Calendar c = Calendar.getInstance();//默认是当前日期
创建一个指定日期的Calendar对象
使用Calendar类代表特定的时间，需要首先创建一个Calendar的对象，然后再设定该对象中的年月日参数来完成。
//创建一个代表2009年6月12日的Calendar对象
Calendar c1 = Calendar.getInstance();
c1.set(2009, 6 - 1, 12);
Calendar类中用一下这些常量表示不同的意义，jdk内的很多类其实都是采用的这种思想
Calendar.YEAR 年份
Calendar.MONTH 月份
Calendar.DATE 日期
Calendar.DAY_OF_MONTH 日期，和上面的字段意义完全相同
Calendar.HOUR 12小时制的小时
Calendar.HOUR_OF_DAY 24小时制的小时
Calendar.MINUTE 分钟
Calendar.SECOND 秒
Calendar.DAY_OF_WEEK 星期几
Calendar c1 = Calendar.getInstance();
// 获得年份
int year = c1.get(Calendar.YEAR);
// 获得月份
int month = c1.get(Calendar.MONTH) + 1;
// 获得日期
int date = c1.get(Calendar.DATE);
// 获得小时
int hour = c1.get(Calendar.HOUR_OF_DAY);
// 获得分钟
int minute = c1.get(Calendar.MINUTE);
// 获得秒
int second = c1.get(Calendar.SECOND);
// 获得星期几（注意（这个与Date类是不同的）：1代表星期日、2代表星期1、3代表星期二，以此类推）
int day = c1.get(Calendar.DAY_OF_WEEK);
标签：ott idt svn header 参数 svc val turn foo
原文地址：http://www.cnblogs.com/jeknight/p/6985365.html
