一、什么是 Java 技术？为何需要 Java？
Java 是由 Sun Microsystems 在 1995 年首先发布的编程语言和计算平台。有许多应用程序和 Web 站点只有在安装 Java 后才能正常工作，而且这样的应用程序和 Web 站点日益增多。Java 快速、安全、可靠。从笔记本电脑到数据中心，从游戏控制台到科学超级计算机，从手机到互联网，Java 无处不在！
Java是一种计算机编程语言，拥有跨平台、面向对象、泛型编程的特性，广泛应用于企业级Web应用开发和移动应用开发。
任职于太阳微系统的詹姆斯·高斯林等人于1990年代初开发Java语言的雏形，最初被命名为Oak，目标设置在家用电器等小型系统的程序语言，应用在电视机、电话、闹钟、烤面包机等家用电器的控制和通信。由于这些智能化家电的市场需求没有预期的高，Sun公司放弃了该项计划。随着1990年代互联网的发展，Sun公司看见Oak在互联网上应用的前景，于是改造了Oak，于1995年5月以Java的名称正式发布。Java伴随着互联网的迅猛发展而发展，逐渐成为重要的网络编程语言。
Java编程语言的风格十分接近C++语言。继承了C++语言面向对象技术的核心，Java舍弃了C++语言中容易引起错误的指针，改以引用替换，同时移除原C++与原来运算符重载，也移除多重继承特性，改用接口替换，增加垃圾回收器功能。在Java SE 1.5版本中引入了泛型编程、类型安全的枚举、不定长参数和自动装/拆箱特性。太阳微系统对Java语言的解释是：“Java编程语言是个简单、面向对象、分布式、解释性、健壮、安全与系统无关、可移植、高性能、多线程和动态的语言”
Java不同于一般的编译语言或直译语言。它首先将源代码编译成字节码，然后依赖各种不同平台上的虚拟机来解释执行字节码，从而实现了“一次编写，到处运行”的跨平台特性。在早期JVM中，这在一定程度上降低了Java程序的运行效率。但在J2SE1.4.2发布后，Java的运行速度有了大幅提升。
二、语言特性
Java之所以被开发，是要达到以下五个目的：
- 应当使用面向对象程序设计方法学
- 应当允许同一程序在不同的计算机平台执行
- 应当包括内建的对计算机网络的支持
- 应当被设计成安全地执行远端代码
- 应当易于使用，并借鉴以前那些面向对象语言（如C++）的长处。
Java技术主要分成几个部分：Java语言、Java运行环境、类库。一般情况下说Java时并不区分指的是哪个部分。
Java在1.5版本时，做了重大改变，太阳公司并1.5版本重命名为Java 5.0。
面向对象
Java的特点之一就是面向对象，是程序设计方法的一种。“面向对象程序设计语言”的核心之一就是开发者在设计软件的时候可以使用自定义的类型和关联操作。代码和数据的实际集合体叫做“对象”。一个对象可以想象成绑定了很多“行为（代码）”和“状态（数据）”的物体。对于数据结构的改变需要和代码进行通信然后操作，反之亦然。面向对象设计让大型软件工程的计划和设计变得更容易管理，能增强工程的健康度，减少失败工程的数量。
跨平台性
Java语言的第二个特性就是跨平台性，也就是说使用Java语言编写的程序可以在编译后不用经过任何更改，就能在任何硬件设备条件下运行。这个特性经常被称为“一次编译，到处运行”。
执行Java应用程序必须安装Java Runtime Environment（JRE），JRE内部有一个Java虚拟机（Java Virtual Machine，JVM）以及一些标准的类库（Class Library）。通过JVM才能在电脑系统执行Java应用程序（Java Application），这与.Net Framework的情况一样，所以电脑上没有安装JVM，那么这些程序将不能够执行。
实现跨平台性的方法是大多数编译器在进行Java语言程序的编码时候会生成一个用字节码写成的“半成品”，这个“半成品”会在Java虚拟机（解释层）的帮助下运行，虚拟机会把它转换成当前所处硬件平台的原始代码。之后，Java虚拟机会打开标准库，进行数据（图片、线程和网络）的访问工作。主要注意的是，尽管已经存在一个进行代码翻译的解释层，有些时候Java的字节码代码还是会被JIT编译器进行二次编译。
有些编译器，比如GCJ，可以自动生成原始代码而不需要解释层。但是这些编译器所生成的代码只能应用于特定平台。并且GCJ目前只支持部分的Java API。
甲骨文公司对于Java的许可是“全兼容的”，这也导致了微软和升阳关于微软的程序不支持RMI和JNI接口、并且增加特性为己所用的法律争端。升阳最终赢得了官司，获得了大约两千万美元的赔偿，法院强制要求微软执行升阳公司关于Java的许可要求。作为回应，微软不再在Windows系统中捆绑Java，最新的Windows版本，Windows Vista和Internet Explorer 7.0版本也不再提供对于Java应用程序和控件的支持。但是升阳公司和其他使用Java运行时系统的公司在Windows操作系统下对用户提供无偿的第三方插件和程序支持。
Java语言使用解释层最初是为了轻巧性。所以这些程序的运行效率比C语言和C++要低很多，用户也对此颇有微词。很多最近的调查显示Java的程序运行速度比几年前要高出许多，有些同样功能的程序的效率甚至超过了C++和C语言编写的程序。
Java语言在最开始应用的时候是没有解释层的，所有需要编译的代码都直接转换成机器的原始代码。这样做的后果就是获得了最佳的性能，但是程序臃肿异常。从JIT技术开始，Java的程序都经过一次转换之后才变成机器码。很多老牌的第三方虚拟机都使用一种叫做“动态编译”的技术，也就是说虚拟机实时监测和分析程序的运行行为，同时选择性地对程序所需要的部分进行编译和优化。所有这些技术都改善了代码的运行速度，但是又不会让程序的体积变得失常。
程序的轻便性事实上是软件编写很难达到的一个目标，Java虽然成功地实现了“一次编译，到处运行”，但是由于平台和平台之间的差异，所编写的程序在转换代码的时候难免会出现微小的、不可察觉的错误和意外。有些程序员对此非常头疼，他们嘲笑Java的程序不是“一次编译，到处运行”，而是“一次编译，到处调试”。以Java AWT为例，早期Java AWT内提供的按钮、文字区等均是以电脑系统所默认的样式而显示。这令Java程序在有些没有提供图案的电脑系统产生错误（在Microsoft Windows设有窗口管理器，在一些Linux distribution则没有）。后来SUN公司针对Java AWT一些问题而推出Java Swing。
平台无关性让Java在服务器端软件领域非常成功。很多服务器端软件都使用Java或相关技术建立。
自动垃圾回收（Garbage Collection）
C++语言被用户诟病的原因之一是大多数C++编译器不支持垃圾收集机制。通常使用C++编程的时候，程序员于程序中初始化对象时，会在主机内存堆栈上分配一块内存与地址，当不需要此对象时，进行析构或者删除的时候再释放分配的内存地址。如果对象是在堆栈上分配的，而程序员又忘记进行删除，那么就会造成内存泄漏（Memory Leak）。长此以往，程序运行的时候可能会生成很多不清除的垃圾，浪费了不必要的内存空间。而且如果同一内存地址被删除两次的话，程序会变得不稳定，甚至崩溃。因此有经验的C++程序员都会在删除之后将指针重置为NULL，然后在删除之前先判断指针是否为NULL。
C++中也可以使用“智能指针”（Smart Pointer）或者使用C++托管扩展编译器的方法来实现自动化内存释放，智能指针可以在标准类库中找到，而C++托管扩展被微软的Visual C++ 7.0及以上版本所支持。智能指针的优点是不需引入缓慢的垃圾收集机制，而且可以不考虑线程安全的问题，但是缺点是如果不善使用智能指针的话，性能有可能不如垃圾收集机制，而且不断地分配和释放内存可能造成内存碎片，需要手动对堆进行压缩。除此之外，由于智能指针是一个基于模板的功能，所以没有经验的程序员在需要使用多态特性进行自动清理时也可能束手无策。
Java语言则不同，上述的情况被自动垃圾收集功能自动处理。对象的创建和放置都是在内存堆栈上面进行的。当一个对象没有任何引用的时候，Java的自动垃圾收集机制就发挥作用，自动删除这个对象所占用的空间，释放内存以避免内存泄漏。
注意程序员不需要修改finalize方法，自动垃圾收集也会发生作用。但是内存泄漏并不是就此避免了，当程序员疏忽大意地忘记解除一个对象不应该有的引用时，内存泄漏仍然不可避免。
不同厂商、不同版本的JVM中的内存垃圾回收机制并不完全一样，通常越新版本的内存回收机制越快，IBM、BEA、SUN等等开发JVM的公司都曾宣称过自己制造出了世界上最快的JVM，JVM性能的世界纪录也在不断的被打破并提高。
IBM有一篇有关Java内存回收机制比不激活垃圾收集机制的C++内存处理快数倍的技术文章，而著名的Java技术书籍《Java编程思想》（Thinking in Java）也有一段论述Java内存及性能达到甚至超过C++的章节。
三、环境
Java的三种技术架构:
JAVAEE：Java Platform Enterprise Edition，开发企业环境下的应用程序，主要针对web程序开发；
JAVASE：Java Platform Standard Edition，完成桌面应用程序的开发，是其它两者的基础；
JAVAME：Java Platform Micro Edition，开发电子消费产品和嵌入式设备，如手机中的程序；
JDK下载地址：http://www.oracle.com/technetwork/cn/java/javase/downloads/jdk7-downloads-1880260.html
1，JDK：Java Development Kit，java的开发和运行环境，java的开发工具和jre。
2，JRE：Java Runtime Environment，java程序的运行环境，java运行的所需的类库+JVM(java虚拟机)。
java运行分两步：一个是编译，一个是运行。
javac：负责的是编译的部分，当执行javac时，会启动java的编译器程序。对指定扩展名的.java文件进行编译。 生成了jvm可以识别的字节码文件。也就是class文件，也就是java的运行程序。
java：负责运行的部分.会启动jvm.加载运行时所需的类库,并对class文件进行执行.
一个文件要被执行,必须要有一个执行的起始点,这个起始点就是main函数.
javac HelloWorld.java
java HelloWorld.class
.class文件主要分为两部分：
- 常量池: 类名，成员变量名和方法引用
- 方法字节码: 各个方法的字节码
运行 java程序的运行过程有两个阶段：
- 加载 即类的.class字节码被加载到内存中，一般第一次使用的时候才会加载(惰性加载)，这时候会为每个 类创建一个Class对象。
- 初始化 由可分为静态初始化和一般初始化，静态初始化在类加载时完成，一般静态初始化自会在Class对象首 次加载的时候进行一次，当创建一个对象时，首先会在堆上分配足够的存储空间，这时候这块存储空间会被清零， 即对象中的所有基本数据类型都会被设置成0，然后再执行字段定义处的初始化动作，最后执行构造器。
四、HelloWorld
public class HelloWorld
{
public static void main（String[] args）
{
System.out.println（"Hello, World!"）;
}
}
五、基本数据类型
4类8种：
1> 逻辑型 -- boolean
2> 文本型 -- char
3> 整数型 -- byte, short, int, long
4> 浮点数型 -- float, double
| 类型 | 占用存储空间/字节 | 表数范围 |
| boolean | 1/8 | true & false |
| char | 2 | 存储Unicode码，单引号赋值 |
| byte | 1 | -128 ~ 127 |
| short | 2 | -2**15 ~ 2**15-1 |
| int | 4 | -2**31 ~ 2**31-1 |
| long | 8 | -2**63 ~ 2**63-1 |
| float | 4 | -3.403E38 ~ 3.403E38 |
| double | 8 | -1.798E308 ~ 1.798E308 |
float 与 double 的区别：
float表示单精度浮点数，32位二进制描述；
double表示双精度浮点数，64位二进制表示；
double精度高，有效数字16位，float精度7位。但double消耗内存是float的两倍，double的运算速度比float慢得多。
♥常量
实数常量默认为 double；
整数常量默认为 int。
0x 和 10 内存中没区别。
1> 十六进制整型常量：以十六进制表示时，需以0x或0X开头，如0xff,0X9A。
2> 八进制整型常量：八进制必须以0开头，如0123，034。
3> 长整型：长整型必须以L作结尾，如9L,342L。
4> 浮点数常量：由于小数常量的默认类型是double型，所以float类型的后面一定要加f(F)。同样带小数的变量默认为double类型。如：f=1.3f;
5> 字符常量：字符型常量需用两个单引号括起来（注意字符串常量是用两个双引号括起来）。
Java中的字符占两个字节。一些常用的转义字符：
1> \r表示接受键盘输入，相当于按下了回车键；
2> \n表示换行；
3> \t表示制表符，相当于Table键；
4> \b表示退格键，相当于Back Space键；
5> \'表示单引号；
6> \''表示双引号；
7> \\表示一个斜杠\。
♥基本数据类型转换
1> boolean 类型不可以转换为其他的数据类型。
2> 容量小的类型自动转换为容量大的数据类型（指表示值得范围大小）：
|
byte, short, char --> int --> long --> float --> double byte, short, char 之间不会互相转换，他们三者在计算时先会转换为 int 类型 |
3> 容量大的数据类型转换为容量小的数据类型时，要加上强制转换符，可能会造成精度降低或溢出。
4> 有多种类型的数据混合运算时，系统首先自动的将所有数据类型转换成容量最大的那一种数据类型，然后再进行计算。
c 语言之所以不能移植，是因为不同系统编译后的类型长度不一致
byte b;
b = 1;
int i=b; //
long l=b; //
float f=b; // 1.0
double d=b; // 1.0 // 如果低级类型为char型，向高级类型（整型）转换时，会转换为对应ASCII码值，例:
char c='c';
int i=c; // 99 //对于byte,short,char三种类型而言，他们是平级的，因此不能相互自动转换，可以使用下述的强制类型转换。
short i=99;
char c=(char)i; //c
// float 类型的两种方式
// 在内存中的形式是不一样的
float f1=0.1f; // 在内存中是float类型
float f2=(float)(0.1); // 在内存中是double类型，强制转换为float类型
// long类型
long l1=123456;
long l2=8888888888; // 错误！！！
long l3=8888888888L; // 后面加L
// byte 类型
byte b1=1;
byte b2=2;
byte b3=129; // 错误！！！超过最大值
六、运算符
1> 算数运算符
+、 -、 *、 /、 %、 ++、 --
2> 赋值运算符
=、 +=、 -=、 *=、 /=、 %=
3> 关系运算符
>、 <、 >=、 <=、 ==、 !=
4> 逻辑运算符
!、 ^、 &、 &&、 |、 ||
除了 !（逻辑非） 都是用于连接两个 boolean 类型表达式
&（逻辑与）: 只有两边都为 true 结果是 true， 否则 false;
&&（短路与）: 和 & 一样，但如果左边为 false，右边就不参与运算;
|（逻辑或）: 只有两边都为 flase 结果是 false， 否则是 true;
||（短路或）: 和 | 一样，但如果左边为 true， 右边就不参与运算;
^（逻辑异）: 两边结果一样为 false， 两边结果不一样为 true;
5> 位运算符
&、 |、 ^、 ~、 >>、 <<、 >>>
// 自加自减练习
// ++、-- 在前面是先加减后赋值，在后面是先赋值在加减
int i1 = 10;
int i2 = 20;
int i = i2++;
System.out.println("i:" + i); //20，是先赋值在自加！
System.out.println("i2:" + i2); //
i = ++i2;
System.out.println("i:" + i); //
System.out.println("i2:" + i2); //
i = --i1;
System.out.println("i:" + i); //
System.out.println("i1:" + i1); //
i = i1--;
System.out.println("i:" + i); //
System.out.println("i1:" + i1); //
自加自减练习
// 逻辑运算符练习
boolean a, b, c;
a = true; b=false;
c = !a; System.out.println(c); //false
c = a ^ b; System.out.println(c); //true
c = a & b; System.out.println(c); //false
c = a && b; System.out.println(c); //false
c = a | b; System.out.println(c); //true
c = a || b; System.out.println(c); //true
逻辑运算符练习
七、基本语句
1> for 循环
for(初始化表达式;判断表达式;递增（递减）表达式){
执行语句;
}
- 初始化表达式：初始化表达式的意义，在于定义循环之前变量的值是多少。
- 判断表达式：判断表达式的作用在于规定循环的终点。
- 递增（递减）表达式：这一项规定每执行一次程序，变量以多少增量或减量进行变化。
2> foreach 循环或者、加强型循环
for(类型 变量 : 数组){
执行语句;
}
JDK 1.5 引进了一种新的循环类型，被称为 foreach 循环或者加强型循环，它能在不使用下标的情况下遍历数组。
3> while 循环
while (条件){
操作;
}
4> do while 循环语句
do/while 语句与 while 语句不同的是，在判断条件之前，先执行大括号内的循环体。
5> switch 语句
switch (key) {
case value:
...
break;
default:
...
break;
}
- 使用 break 语句，避免 case 穿透；
- 多个 case key 合并到一起；
- default 可以省略， 也以写在任意位置，如果将default语句放在了第一行，则不管value是否匹配，程序会从default开始执行直到第一个break出现；
- java 中的 switch 支持的类型可以为 byte,char,short,int 中的一种，JDK版本为1.7及以上支持String。
6> break & continue
跳出整个循环与跳出本次循环。
7> 三元运算
布尔表达式?值一:值二
布尔表达式为true结果为值一，表达式为false结果为值二
java三元表达式有字符强转的功能,会把后面的强转为和前面的类型一样
- 如果前面是int型 会把后面字符变成对应的ascii码。
- 如果前面是char型 会把后面数字转换成对应的字
public class OneHundredAnd{
public static void main(String[] args){
int result=0;
for(int i=1;i<=100;i++){
result+=i;
}
System.out.println(result);
}
}
for 循环, 计算1+2+3+4......+100的结果
public class TestArray {
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5};
// 打印所有数组元素
for (double element: myList) {
System.out.println(element);
}
}
}
foreach 循环
public class OneHundredAnd{
public static void main(String[] args){
int a=1,result=0;
while(a<=100){
result+=a++;
}
System.out.println(result);
}
}
while 循环, 计算1+2+3+4......+100的结果
public class OneHundredAnd{
public static void main(String[] args){
int a=1,result=0;
do{
result+=a++;
}while(a<=100);
System.out.println(result);
}
}
do while 循环, 计算1+2+3+4......+100的结果
public class PrimeNumbers{
public static void main(String[] args){
// 输出100~200内的质数
// 只有1和它本身这两个因数的自然数叫做质数.还可以说成质数只有1和它本身两个约数.
// 素数是这样的整数,它除了能表示为它自己和1的乘积以外,不能表示为任 何其它两个整数的乘积.
// 例如: 12 ＝6×2＝4×3,所以12不是素数.
for (int i=101; i<200; i+=2){
for (int n=2; n<i; n++){
if (i % n != 0){
System.out.println(i);
break;
}
}
}
}
}
输出100~200内的质数
public class DataConversion {
public static void main(String[] args){
switch (18) {
case 18:
System.out.print("I'm eighteen years old, fighting.");
break;
case 19:
case 20:
case 21:
case 22:
System.out.print("I'm twenty years old, fighting.");
break;
default:
System.out.print("Grow up to go away ^.^.");
break;
}
}
}
case 语句 practice
public class SimpleUnary{
public static void main(String[] args) {
char a = 'a';
int b = 8;
System.out.println(false?a:b); //打印b，b是8，所以打印出8
System.out.println(false?a:8); //打印8，但a是char型的，所以打印8的char字 //符，也就是backspace
System.out.println(false?8:a); //打印int型，也就是a
System.out.println(false?b:'a'); //打印a的ASCII码
}
}
三元运算 practice
八、Number 类
所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。
| 序号 | 方法与描述 |
|---|---|
| 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() 返回一个随机数。 |
public class Numbers {
public static String getType(Object o){
return o.getClass().toString();
}
public static void main(String[] args){
// // xxxValue() 将number对象转换为xxx数据类型的值并返回。
// Integer i1=1;
// float f1 = i1.floatValue();
// System.out.println(f1 + " " + getType(f1)); //1.0 class java.lang.Float
// int f2 = i1.intValue();
// System.out.println(f2 + " " + getType(f2)); //1 class java.lang.Integer
// byte f3 = i1.byteValue();
// System.out.println(f3 + " " + getType(f3)); //1 class java.lang.Byte
//// i1.compareTo(1);
// // 比较这个Number对象的参数. 一样返回0，否则-1.
// Integer i1=1;
// int i2 = i1.compareTo(1);
// System.out.println(i2);
// // 确定这个数字对象是否等于参数.一样返回true，否则false.
// Integer i1=1;
// byte i2=1;
// boolean i3 = i1.equals(i2);
// System.out.println(i3); //false
// //返回一个 Number 对象指定的内置数据类型
// //nteger.valueOf()方法基于减少对象创建次数和节省内存的考虑，
// //缓存了[-128,127]之间的数字。此数字范围内传参则直接返回缓存中的对象。
// Integer i1=1;
// Integer i2 = Integer.valueOf(i1);
// System.out.println(i2); //1
// //以字符串形式返回值。
// Integer i1=1;
// String i2 = i1.toString();
// System.out.println(i2); //1
// //将字符串解析为int类型。
// String i1="9";
// Integer i2 = Integer.parseInt(i1);
// System.out.println(i2); //9
// //返回参数的绝对值。
// Integer i1=-1;
// Integer i2 = Math.abs(i1);
// System.out.println(i2); //1
// //对整形变量向左取整，返回类型为double型。
// int i1=1;
// double i2 = Math.ceil(i1);
// System.out.println(i2); //1.0
// //对整型变量向右取整。返回类型为double类型。
// int i1=1;
// double i2 = Math.floor(i1);
// System.out.println(i2); //1.0
// //返回与参数最接近的整数。返回类型为double。
// double i1=1.623;
// double i2 = Math.rint(i1);
// System.out.println(i2); //2.0
// //返回一个最接近的int、long型值。
// double i1=1.623;
// long i2 = Math.round(i1);
// System.out.println(i2); //2
// //返回两个参数中的最小值。
// double i1=1.6;
// double i2=1.8;
// double i3 = Math.min(i1, i2);
// System.out.println(i3); //1.6
// //返回两个参数中的最大值。
// int i1=9;
// int i2=5;
// int i3 = Math.max(i1, i2);
// System.out.println(i3); //9
// //返回两个参数中的最大值。
// int i1=9;
// int i2=5;
// int i3 = Math.max(i1, i2);
// System.out.println(i3); //9
// //返回自然数底数e的参数次方。
// double i1=9;
// double i2 = Math.exp(i1);
// System.out.println(i2); //8103.083927575384
// //返回参数的自然数底数的对数值。
// double i1=9;
// double i2 = Math.log(i1);
// System.out.println(i2); //2.1972245773362196
// //返回第一个参数的第二个参数次方。2的3次方.
// double i1=2;
// double i2=3;
// double i3 = Math.pow(i1, i2);
// System.out.println(i3); //8.0
// //求参数的算术平方根。
// double i1=9;
// double i2 = Math.sqrt(i1);
// System.out.println(i2); //3.0
// //求指定double类型参数的正弦值。
// double i1=3;
// double i2 = Math.sin(i1);
// System.out.println(i2); //3.0
// //求指定double类型参数的余弦值。
// double i1=3;
// double i2 = Math.cos(i1);
// System.out.println(i2); //-0.9899924966004454
// //求指定double类型参数的正切值。
// double i1=3;
// double i2 = Math.tan(i1);
// System.out.println(i2); //-0.1425465430742778
// //求指定double类型参数的反正弦值。NaN
// double i1=1;
// double i2 = Math.asin(i1);
// System.out.println(i2); //1.5707963267948966
// //求指定double类型参数的反余弦值。NaN
// double i1=2;
// double i2 = Math.acos(i1);
// System.out.println(i2); //0.0
// //求指定double类型参数的反正切值。
// double i1=3;
// double i2 = Math.atan(i1);
// System.out.println(i2); //1.2490457723982544
// //将笛卡尔坐标转换为极坐标，并返回极坐标的角度值。
// double i1=3;
// double i2=3;
// double i3 = Math.atan2(i1, i2);
// System.out.println(i3); //0.7853981633974483
// //将参数转化为角度。
// double i1=3;
// double i2 = Math.toDegrees(i1);
// System.out.println(i2); //171.88733853924697
// //将角度转换为弧度。
// double i1=3;
// double i2 = Math.toRadians(i1);
// System.out.println(i2); //0.05235987755982988
// //返回一个随机数。
// double i1 = Math.random();
// System.out.println(i1); //0.9591935059236623
}
}
Number practice
九、Character 类
Character 类用于对单个字符进行操作。
Character 类在对象中包装一个基本类型 char 的值
| 序号 | 方法与描述 |
|---|---|
| 1 | isLetter() 是否是一个字母 |
| 2 | isDigit() 是否是一个数字字符 |
| 3 | isWhitespace() 是否是一个空格 |
| 4 | isUpperCase() 是否是大写字母 |
| 5 | isLowerCase() 是否是小写字母 |
| 6 | toUpperCase() 指定字母的大写形式 |
| 7 | toLowerCase() 指定字母的小写形式 |
| 8 | toString() 返回字符的字符串形式，字符串的长度仅为1 |
public class Characters {
public static void main(String[] args){
char c1 = 'm';
// //是否是一个字母
// boolean b1 = Character.isLetter(c1);
// System.out.println(b1); //true
// //是否是一个数字字符
// boolean b1 = Character.isDigit(c1);
// System.out.println(b1); //false
// //是否是一个空格
// boolean b1 = Character.isWhitespace(c1);
// System.out.println(b1); //false
// //是否是大写字母
// boolean b1 = Character.isUpperCase(c1);
// System.out.println(b1); //false
// //是否是小写字母
// boolean b1 = Character.isLowerCase(c1);
// System.out.println(b1); //true
// //指定字母的大写形式,变大写
// char b1 = Character.toUpperCase(c1);
// System.out.println(b1); //M
// //指定字母的小写形式,变小写
// char b1 = Character.toLowerCase(c1);
// System.out.println(b1); //m
// //返回字符的字符串形式，字符串的长度仅为1
// String b1 = Character.toString(c1);
// System.out.println(b1); //m
}
}
Character practice
十、String 类
使用关键字和构造方法来创建 String 对象。
String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了（如果需要对字符串做很多修改，那么应该选择使用 StringBuffer & StringBuilder 类）
String 类有 11 种构造方法，这些方法提供不同的参数来初始化字符串，比如提供一个字符数组参数:
public class StringDemo{
public static void main(String args[]){
char[] hello = { 's', 'u', 'o', 'n', 'i', 'n', 'g'};
String hellos = new String(hello);
System.out.println( hellos );
}
}
String()
初始化一个新创建的 String 对象，它表示一个空字符序列。
String(byte[] bytes)
构造一个新的 String，方法是使用平台的默认字符集解码字节的指定数组。
String(byte[] ascii, int hibyte)
已过时。 该方法无法将字节正确转换为字符。从 JDK 1.1 起，完成该转换的首选方法是通过 String 构造方法，该方法接受一个字符集名称或使用平台的默认字符集。
String(byte[] bytes, int offset, int length)
构造一个新的 String，方法是使用指定的字符集解码字节的指定子数组。
String(byte[] ascii, int hibyte, int offset, int count)
已过时。 该方法无法将字节正确转换为字符。从 JDK 1.1 开始，完成该转换的首选方法是通过 String 构造方法，它接受一个字符集名称，或者使用平台默认的字符集。
String(byte[] bytes, int offset, int length, String charsetName)
构造一个新的 String，方法是使用指定的字符集解码字节的指定子数组。
String(byte[] bytes, String charsetName)
构造一个新的 String，方法是使用指定的字符集解码指定的字节数组。
String(char[] value)
分配一个新的 String，它表示当前字符数组参数中包含的字符序列。
String(char[] value, int offset, int count)
分配一个新的 String，它包含来自该字符数组参数的一个子数组的字符。
String(int[] codePoints, int offset, int count)
分配一个新的 String，它包含该 Unicode 代码点数组参数的一个子数组的字符。
String(String original)
初始化一个新创建的 String 对象，表示一个与该参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的一个副本。
String(StringBuffer buffer)
分配一个新的字符串，它包含当前包含在字符串缓冲区参数中的字符序列。
String 类 11 种构造方法
| 序号 | 方法描述 |
|---|---|
| 1 |
char charAt(int index) 返回指定索引处的 char 值。 |
| 2 |
int compareTo(Object o) 把这个字符串和另一个对象比较。 |
| 3 |
int compareTo(String anotherString) 按字典顺序比较两个字符串。 |
| 4 |
int compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。 |
| 5 |
String concat(String str) 将指定字符串连接到此字符串的结尾。 |
| 6 |
boolean contentEquals(StringBuffer sb) 当且仅当字符串与指定的StringButter有相同顺序的字符时候返回真。 |
| 7 |
static String copyValueOf(char[] data) 返回指定数组中表示该字符序列的 String。 |
| 8 |
static String copyValueOf(char[] data, int offset, int count) 返回指定数组中表示该字符序列的 String。 |
| 9 |
boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束。 |
| 10 |
boolean equals(Object anObject) 将此字符串与指定的对象比较。 |
| 11 |
boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写。 |
| 12 |
byte[] getBytes() 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。 |
| 13 |
byte[] getBytes(String charsetName) 使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。 |
| 14 |
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此字符串复制到目标字符数组。 |
| 15 |
int hashCode() 返回此字符串的哈希码。 |
| 16 |
int indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。 |
| 17 |
int indexOf(int ch, int fromIndex) 返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。 |
| 18 |
int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引。 |
| 19 |
int indexOf(String str, int fromIndex) 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。 |
| 20 |
String intern() 返回字符串对象的规范化表示形式。 |
| 21 |
int lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。 |
| 22 |
int lastIndexOf(int ch, int fromIndex) 返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。 |
| 23 |
int lastIndexOf(String str) 返回指定子字符串在此字符串中最右边出现处的索引。 |
| 24 |
int lastIndexOf(String str, int fromIndex) 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。 |
| 25 |
int length() 返回此字符串的长度。 |
| 26 |
boolean matches(String regex) 告知此字符串是否匹配给定的正则表达式。 |
| 27 |
boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) 测试两个字符串区域是否相等。 |
| 28 |
boolean regionMatches(int toffset, String other, int ooffset, int len) 测试两个字符串区域是否相等。 |
| 29 |
String replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。 |
| 30 |
String replaceAll(String regex, String replacement 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。 |
| 31 |
String replaceFirst(String regex, String replacement) 使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。 |
| 32 |
String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。 |
| 33 |
String[] split(String regex, int limit) 根据匹配给定的正则表达式来拆分此字符串。 |
| 34 |
boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始。 |
| 35 |
boolean startsWith(String prefix, int toffset) 测试此字符串从指定索引开始的子字符串是否以指定前缀开始。 |
| 36 |
CharSequence subSequence(int beginIndex, int endIndex) 返回一个新的字符序列，它是此序列的一个子序列。 |
| 37 |
String substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。 |
| 38 |
String substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。 |
| 39 |
char[] toCharArray() 将此字符串转换为一个新的字符数组。 |
| 40 |
String toLowerCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为小写。 |
| 41 |
String toLowerCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。 |
| 42 |
String toString() 返回此对象本身（它已经是一个字符串！）。 |
| 43 |
String toUpperCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。 |
| 44 |
String toUpperCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。 |
| 45 |
String trim() 返回字符串的副本，忽略前导空白和尾部空白。 |
| 46 |
static String valueOf(primitive data type x) 返回给定data type类型x参数的字符串表示形式。 |
import java.nio.charset.Charset;
import javax.print.DocFlavor.BYTE_ARRAY;
public class Strings {
public static void main(String[] args){
String s1 = "suoning";
String s2 = "nick";
// //返回指定索引处的 char 值。
// char c1 = s1.charAt(3);
// System.out.println(c1); //n
// //把这个字符串和另一个对象比较.等于返回0,此字符串小于字符串参数返回小于0,大于返回大于0.
// int c1 = s1.compareTo(s2);
// System.out.println(c1); //5
// //将指定字符串连接到此字符串的结尾。
// String c1 = s1.concat(s2);
// System.out.println(c1); //suoningnick
// //当且仅当字符串与指定的StringButter有相同顺序的字符时候返回真。
// StringBuffer s3 = new StringBuffer("suoning");
// boolean c1 = s1.contentEquals(s3);
// System.out.println(c1); //true
// //返回指定数组中表示该字符序列的 String。
// char[] s3 = {'s', 'u', 'o', ' ', 'n', 'i', 'n', 'g'};
// String c1 = s1.copyValueOf(s3);
// System.out.println(c1); //suo ning
// String c2 = s1.copyValueOf(s3, 1, 6);
// System.out.println(c2); //uo nin
// //测试此字符串是否以指定的后缀结束。
// boolean c1 = s1.endsWith(s2);
// System.out.println(c1); //false
// //将此字符串与指定的对象比较。
// boolean c1 = s1.equals(s2);
// System.out.println(c1); //false
// //将此 String 与另一个 String 比较，不考虑大小写。
// boolean c1 = s1.equalsIgnoreCase(s2);
// System.out.println(c1); //false
// //使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
// byte[] c1 = s1.getBytes();
// System.out.println(c1); //[B@11e78461
// //将字符从此字符串复制到目标字符数组。
// //srcBegin -- 字符串中要复制的第一个字符的索引。 rcEnd -- 字符串中要复制的最后一个字符之后的索引。
// //dst -- 目标数组。 dstBegin -- 目标数组中的起始偏移量。
// //没有返回值，但会抛出 IndexOutOfBoundsException 异常。
// //char[] s3 = new char[5];
// s1.getChars(1,6,s3,0);
// System.out.println(s3); //uonin
// //返回此字符串的哈希码。
// int s3 = s1.hashCode();
// System.out.println(s3); //-1855756159
// //返回指定字符在此字符串中第一次出现处的索引。
// int s3 = s1.indexOf('s');
// System.out.println(s3); //0
// //返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
// int s3 = s1.indexOf('n', 3);
// System.out.println(s3); //3
// // 返回字符串对象的规范化表示形式。
// String s3 = s1.intern();
// System.out.println(s3); //suoning
// // 返回指定字符在此字符串中最后一次出现处的索引。
// int s3 = s1.lastIndexOf('n');
// System.out.println(s3); //5
// // 返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
// int s3 = s1.lastIndexOf('n', 3);
// System.out.println(s3); //3
// // 返回指定子字符串在此字符串中最右边出现处的索引。
// String s4 = new String("ning");
// int s3 = s1.lastIndexOf(s4);
// System.out.println(s3); //3
// //返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
// String s4 = new String("ning");
// int s3 = s1.lastIndexOf(s4, 2);
// System.out.println(s3); //-1
// //返回此字符串的长度。
// int s3 = s1.length();
// System.out.println(s3); //7
// //告知此字符串是否匹配给定的正则表达式。
// boolean s3 = s1.matches("suo(.*)");
// System.out.println(s3); //true
//测试两个字符串区域是否相等。
//ignoreCase -- 如果为 true，则比较字符时忽略大小写。
//toffset -- 此字符串中子区域的起始偏移量。
//other -- 字符串参数。
//toffset -- 字符串参数中子区域的起始偏移量。
//len -- 要比较的字符数。
// boolean s3 = s1.regionMatches(3, s2, 6, 4);
// System.out.println(s3); //false
// boolean s3 = s1.regionMatches(true, 3, s2, 6, 4);
// System.out.println(s3); //false
// //返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
// String s3 = s1.replace(' ', 'm');
// System.out.println(s3); //suoning
// //返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
// String s3 = s1.replace(' ', 'm');
// System.out.println(s3); //suoning
// // 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
// String s3 = s1.replaceAll(".*", "m");
// System.out.println(s3); //mm
// //使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
// String s3 = s1.replaceFirst("n", "m");
// System.out.println(s3); //suoming
// //根据给定正则表达式的匹配拆分此字符串。
// String s5 = new String("suo ning");
// String[] s3 = s5.split(" ", 0);
// for (String retval: s3){
// System.out.println(retval); //suo、ning
// }
// // 测试此字符串是否以指定的前缀开始。
// boolean b1 = s1.startsWith(s2);
// System.out.println(b1); //false
// //测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
// boolean b1 = s1.startsWith(s2, 3);
// System.out.println(b1); //false
// //返回一个新的字符序列，它是此序列的一个子序列。
// String s3 = s1.substring(2, 6);
// System.out.println(s3); //onin
// //返回一个新的字符序列，它是此序列的一个子序列。
// CharSequence s3 = s1.subSequence(2, 6);
// System.out.println(s3); //onin
// //返回一个新的字符序列，它是此序列的一个子字符串。
// String s3 = s1.substring(2, 6);
// System.out.println(s3); //onin
// String s3 = s1.substring(2);
// System.out.println(s3); //oning
// //将此字符串转换为一个新的字符数组。
// System.out.println(s1.toCharArray()); //suoning
// //使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
// String s3 = s1.toLowerCase();
// System.out.println(s3); //suoning
// // 返回此对象本身（它已经是一个字符串！
// String s3 = s1.toString();
// System.out.println(s3); //suoning
// // 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
// String s3 = s1.toUpperCase();
// System.out.println(s3); //SUONING
// // 返回字符串的副本，忽略前导空白和尾部空白。
// String s3 = s1.trim();
// System.out.println(s3); //suoning
// // 返回给定data type类型x参数的字符串表示形式。
// String s3 = String.valueOf(s1);
// System.out.println(s3); //suoning
}
}
String practice
十一、StringBuffer & StringBuilder 类
当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。
和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。
StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 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 中的字符替换此序列的子字符串中的字符 |
| 6 |
int capacity() 返回当前容量。 |
| 7 |
char charAt(int index) 返回此序列中指定索引处的 char 值。 |
| 8 |
void ensureCapacity(int minimumCapacity) 确保容量至少等于指定的最小值。 |
| 9 |
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此序列复制到目标字符数组 dst。 |
| 10 |
int indexOf(String str) 返回第一次出现的指定子字符串在该字符串中的索引。 |
| 11 |
int indexOf(String str, int fromIndex) 从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。 |
| 12 |
int lastIndexOf(String str) 返回最右边出现的指定子字符串在此字符串中的索引。 |
| 13 |
int lastIndexOf(String str, int fromIndex) 返回最后一次出现的指定子字符串在此字符串中的索引。 |
| 14 |
int length() 返回长度（字符数）。 |
| 15 |
void setCharAt(int index, char ch) 将给定索引处的字符设置为 ch。 |
| 16 |
void setLength(int newLength) 设置字符序列的长度。 |
| 17 |
CharSequence subSequence(int start, int end) 返回一个新的字符序列，该字符序列是此序列的子序列。 |
| 18 |
String substring(int start) 返回一个新的 String，它包含此字符序列当前所包含的字符子序列。 |
| 19 |
String substring(int start, int end) 返回一个新的 String，它包含此序列当前所包含的字符子序列。 |
| 20 |
String toString() 返回此序列中数据的字符串表示形式。 |
public class StringBufferBuilders {
public static void main(String[] args){
StringBuffer s1 = new StringBuffer("suoning");
// //将指定的字符串追加到此字符序列。
// String s2 = "nick";
// StringBuffer s3 = s1.append(s2);
// System.out.println(s3); //suoningnick
// //将此字符序列用其反转形式取代。
// StringBuffer s3 = s1.reverse();
// System.out.println(s3); //gninous
// //移除此序列的子字符串中的字符。
// StringBuffer s3 = s1.delete(0, 3);
// System.out.println(s3); //ning
// //将 int 参数的字符串表示形式插入此序列中。
// StringBuffer s3 = s1.insert(3, 99);
// System.out.println(s3); //suo99ning
// //使用给定 String 中的字符替换此序列的子字符串中的字符。
// StringBuffer s3 = s1.replace(0, 3, "nick");
// System.out.println(s3); //nickning
// //返回当前容量。
// int s3 = s1.capacity();
// System.out.println(s3); //23
// //返回此序列中指定索引处的 char 值。
// char s3 = s1.charAt(3);
// System.out.println(s3); //n
// //确保容量至少等于指定的最小值。
// s1.ensureCapacity(1);
// System.out.println(s1.capacity()); //23
// //将字符从此序列复制到目标字符数组 dst。
// char[] s2 = new char[4];
// s1.getChars(3,7,s2,0);
// System.out.println(s2); //ning
// //返回第一次出现的指定子字符串在该字符串中的索引。
// String s2 = "nick";
// int s3 = s1.indexOf(s2);
// System.out.println(s3); //-1
// //从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。
// String s2 = "nick";
// int s3 = s1.indexOf(s2, 2);
// System.out.println(s3); //-1
// //返回最右边出现的指定子字符串在此字符串中的索引。
// String s2 = "nick";
// int s3 = s1.lastIndexOf(s2);
// System.out.println(s3); //-1
// //返回最后一次出现的指定子字符串在此字符串中的索引。
// String s2 = "nick";
// int s3 = s1.lastIndexOf(s2, 3);
// System.out.println(s3); //-1
// // 返回长度（字符数）。
// int s3 = s1.length();
// System.out.println(s3); //7
// //将给定索引处的字符设置为 ch。
// s1.setCharAt(3, 'm');
// System.out.println(s1); //suoming
// //设置字符序列的长度
// s1.setLength(9);
// System.out.println(s1.length()); //9
// //返回一个新的字符序列，该字符序列是此序列的子序列。
// CharSequence s3 = s1.subSequence(3, 7);
// System.out.println(s3); //ning
// //返回一个新的 String，它包含此字符序列当前所包含的字符子序列。
// String s3 = s1.substring(3);
// System.out.println(s3); //ning
// //返回一个新的 String，它包含此序列当前所包含的字符子序列。
// String s3 = s1.substring(3,7);
// System.out.println(s3); //ning
// //返回此序列中数据的字符串表示形式
// String s3 = s1.toString();
// System.out.println(s3); //suoning
}
}
StringBuffer & StringBuilder practice
十二、数组
Java 语言中提供的数组是用来存储固定大小的同类型元素。
// 申明及创建数组
int a1[] = new int[6]; //不推荐写法,来源于C/C++
int[] a2 = new int[6];
int[] a3 = {1, 2, 3, 4, 5, 6};
数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 a2.length-1。
//多维数组
String s[][] = new String[5][9];
s[0][0] = new String("nick");
s[0][1] = new String("good");
s[1][0] = new String("jenny");
s[1][1] = new String("yep");
s[1][2] = new String("!");
public class TestArray {
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5};
// 打印所有数组元素
for (int i = 0; i < myList.length; i++) {
System.out.println(myList[i] + " ");
}
// 计算所有元素的总和
double total = 0;
for (int i = 0; i < myList.length; i++) {
total += myList[i];
}
System.out.println("Total is " + total);
// 查找最大元素
double max = myList[0];
for (int i = 1; i < myList.length; i++) {
if (myList[i] > max) max = myList[i];
}
System.out.println("Max is " + max);
}
}
数组 practice
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等）。 |
import java.util.Arrays;
public class MyArrayOfs {
public static void main(String[] args){
int a1[] = new int[6];
int[] a2 = new int[6];
int[] a3 = {1, 2, 3, 4, 5, 6};
int[] a5 = {1, 2, 3, 9, 8, 8};
int[] a6 = {1, 2, 3, 4, 5, 6};
// // public static boolean equals(long[] a, long[] a2)
// //如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
// boolean b1 = Arrays.equals(a3, a5);
// System.out.println(b1); //false
// boolean b2 = Arrays.equals(a3, a6);
// System.out.println(b2); //true
// //public static void fill(int[] a, int val)
// //填充值
// //将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
// Arrays.fill(a2, 9);
// System.out.println(a2[5]); //9
// //public static void sort(Object[] a)
// //对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
// Arrays.sort(a5);
// for(int i: a5) {
// System.out.println(i); //1、2、3、8、8、9
// }
// //public static int binarySearch(Object[] a, Object key)
// //用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
// int index1 = Arrays.binarySearch(a5, 9);
// System.out.println(index1); //-7
// Arrays.sort(a5);
// int index2 = Arrays.binarySearch(a5, 8);
// System.out.println(index2); //4
// int index3 = Arrays.binarySearch(a5, 9);
// System.out.println(index3); //
}
}
数组 practice
十三、Date 日期时间
java.util 包提供了 Date 类来封装当前的日期和时间。
# 实例化 Date 对象
import java.util.Date; Date d1 = new Date();
long t1 = 1514736000000L;
Date d2 = new Date(t1);
System.out.println(d1); //Mon Dec 05 23:59:59 CST 2016
System.out.println(d2); //Mon Jan 01 00:00:00 CST 2018
Date 对象的方法：
| 序号 | 方法和描述 |
|---|---|
| 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表示形式，并返回该字符串。 |
import java.util.Date;
public class DateTimes {
public static void main(String[] args){
Date d1 = new Date();
long t1 = 1514736000000L;
Date d2 = new Date(t1);
System.out.println(d1); //Mon Dec 05 23:59:59 CST 2016
System.out.println(d2); //Mon Jan 01 00:00:00 CST 2018
// // boolean after(Date date)
// //若当调用此方法的Date对象在指定日期之前\后返回true,否则返回false。
// boolean b1 = d2.after(d1);
// System.out.println(b1); //true
// // int compareTo(Date date)
// //比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数
// int b1 = d2.compareTo(d1);
// System.out.println(b1); //1
// // int compareTo(Object obj)
// //若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。
// int b1 = d2.compareTo(d1);
// System.out.println(b1); //1
// //boolean equals(Object date)
// //当调用此方法的Date对象和指定日期相等时候返回true,否则返回false
// boolean b1 = d2.equals(d1);
// System.out.println(b1); //false
// // long getTime( )
// //返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
// long l1 = d2.getTime();
// System.out.println(l1); //1514736000000
// //int hashCode( )
// //返回此对象的哈希码值。
// long l1 = d2.hashCode();
// System.out.println(l1); //-1387455136
// //void setTime(long time)
// //用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。
// d1.setTime(t1);
// System.out.println(d1); //Mon Jan 01 00:00:00 CST 2018
// //String toString( )
// //转换Date对象为String表示形式，并返回该字符串。
// d2.toString();
// System.out.println(d2); //Mon Jan 01 00:00:00 CST 2018
}
}
Date practice
import java.util.Date;
public class DateDemo {
public static void main(String args[]) {
// 初始化 Date 对象
Date date = new Date();
// 使用 toString() 函数显示日期时间
System.out.println(date.toString());
}
}
获取当前日期时间
使用DateFormat 格式化日期
日期和时间转换字符
| 字符 | 描述 | 例子 |
| c | 完整的日期和时间 | Mon May 04 09:51:52 CDT 2009 |
| F | ISO 8601 格式日期 | 2004-02-09 |
| D | U.S. 格式日期 (月/日/年) | 02/09/2004 |
| T | 24小时时间 | 18:05:19 |
| r | 12小时时间 | 06:05:19 pm |
| R | 24小时时间，不包含秒 | 18:05 |
| Y | 4位年份(包含前导0) | 2004 |
| y | 年份后2位(包含前导0) | 04 |
| C | 年份前2位(包含前导0) | 20 |
| B | 月份全称 | February |
| b | 月份简称 | Feb |
| m | 2位月份(包含前导0) | 02 |
| d | 2位日子(包含前导0) | 03 |
| e | 2位日子(不包含前导0) | 9 |
| A | 星期全称 | Monday |
| a | 星期简称 | Mon |
| j | 3位年份(包含前导0) | 069 |
| H | 2位小时(包含前导0), 00 到 23 | 18 |
| k | 2位小时(不包含前导0), 0 到 23 | 18 |
| I | 2位小时(包含前导0), 01 到 12 | 06 |
| l | 2位小时(不包含前导0), 1 到 12 | 6 |
| M | 2位分钟(包含前导0) | 05 |
| S | 2位秒数(包含前导0) | 19 |
| L | 3位毫秒(包含前导0) | 047 |
| N | 9位纳秒(包含前导0) | 047000000 |
| P | 大写上下午标志 | PM |
| p | 小写上下午标志 | pm |
| z | 从GMT的RFC 822数字偏移 | -0800 |
| Z | 时区 | PST |
| s | 自 1970-01-01 00:00:00 GMT的秒数 | 1078884319 |
| Q | 自 1970-01-01 00:00:00 GMT的毫妙 | 1078884319047 |
//使用两个字母格式，它以t开头并且以下面表格中的一个字母结尾。 import java.util.Date;
public class DateTimes {
public static void main(String args[]) {
//初始化 Date 对象
Date date = new Date();
//使用toString()显示日期和时间
String str = String.format("Current Date/Time : %tc", date );
System.out.println(str); //Current Date/Time : Sat Jan 1 00:00:00 MST 2018
System.out.printf("%1$s %2$tB %2$td, %2$tY", "Due date:", date); //Jan date: January 01, 2018
System.out.printf("%s %tB %<te, %<tY", "Due date:", date); //Jan date: January 01, 2018
}
}
//解析字符串为时间 import java.util.*;
import java.text.*; public class DateTimes {
public static void main(String args[]) {
SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd");
String input = args.length == 0 ? "2018-01-01" : args[0];
System.out.print(input + " Parses as ");
Date t;
try {
t = ft.parse(input);
System.out.println(t);
} catch (ParseException e) {
System.out.println("Unparseable using " + ft);
//2018-01-01 Parses as Mon Jan 01 00:00:00 CST 2018
}
}
}
解析字符串为时间
//Java 休眠(sleep)
import java.util.*;
public class DateTimes {
public static void main(String args[]) {
try {
System.out.println(new Date( ) + "\n");
Thread.sleep(1000*3); // 休眠3秒
System.out.println(new Date( ) + "\n");
} catch (Exception e) {
System.out.println("Got an exception!");
}
}
}
Java 休眠(sleep)
//检测时间间隔（以毫秒为单位）
import java.util.*;
public class DateTimes {
public static void main(String args[]) {
try {
long start = System.currentTimeMillis( );
System.out.println(new Date( ) + "\n");
Thread.sleep(5*20*5);
System.out.println(new Date( ) + "\n");
long end = System.currentTimeMillis( );
long diff = end - start;
System.out.println("Difference is : " + diff); //Difference is : 520
} catch (Exception e) {
System.out.println("Got an exception!");
}
}
}
检测时间间隔