java总结
第一章
修饰class类名 {
程序代码
}编写的代码如下
public class Hi {
static String s1="你好";
public static void main(String[] args) {
// TODO Auto-generated method stub
String s2="java";
System.out.print(s1);
System.out.print(s2);
}
} 
数据类型：分为整数类型和浮点类型。（byte，short，interesting，long) (float、double)
数据类型
内存空间
取值范围 默认值
byte 8 -128~127 0
short 16 -2¹⁵~2¹⁵ 0
int 32 -2³²~2³²⁻¹ 0
long 64 -2⁶³~2⁶⁴⁻¹ 0L
float 32 1.4E-45~3.4028235e358 0.0F
double 64 4.9E-324~1.7976931348623157E308 0.0
public class Thirdone {
public static void main(String[] args) {
// TODO Auto-generated method stub
byte b=1;//定义byte形
System.out.println(b);//输出换行
short z=12345;//定义short形
System.out.println(z);//输出换行
int i=11254;//定义int形变量
System.out.println(i);//输出换行
long l=7946626126L;//定义long形L大写
System.out.println(l);//输出换行
float h=9.99F;//定义float单精度浮点型
System.out.println(h);//输出
double m=5.66D;//定义double双精度浮点型
System.out.println(m);//输出
}
}
2.例题3.2根据身高体重计算BMI指数
public class BMIexponene{
public static void main(String[] args) {
// TODO Auto-generated method stub
double height=1.71;//定义double
int weight=70;//定义weight
double exponent=weight/(height*weight);//计算定义重量除以身高和重量乘积
System.out.println("您的身高为："+height);//输入身高
System.out.println("您的体重为："+weight);//输入体重
System.out.println("您的BMI指数为："+exponent);//BMI指数
System.out.println("您的体重属于：");//输入体重
if(exponent<18.5) { //判断语句
System.out.println("体重过轻");//判断体重过轻
}
if(exponent>=18.5&&exponent<24.9) { //判断体重正常
System.out.println("正常范围");
}
if(exponent>=24.9&&exponent<29.9) {//判断体重过重
System.out.println("体重过重");
}
if(exponent>=29.9){
System.out.println("肥胖");}//判断体重肥胖
}
}
//输出
3.字符类型
char
public class Char {
public static void main(String[] args) {
// TODO Auto-generated method stub
char c1='@';//定义字符c1
char c2='\u2650';//定义字符c2
System.out.println(c1);//输出
System.out.println(c2);
}
}
Boolean布尔运算符（注意大写）
public class TrueOrFalse {
public static void main(String[] args) {
// TODO Auto-generated method stub
boolean b1=true;
boolean b2=Boolean.FALSE;
System.out.println(b1);
System.out.println(b2);
}
}
第二章
目录
2.2变量与常量
例 2.1 声明double型常量，并给常量赋值，使用常量进行计算。
2.3基本数据类型
例2.2给int型变量按照十进制、八进制、十六进制赋值
例2.3 展示4.35*100的错误结果，并给出解决方案。
例2.4计算2.0-1.9的结果
2.3字符类型
例2.5使用转义字符
例2.6声明boolean型变量
2.4数据类型转换
例 2.7创建不同数值类型的变量，进行隐式转换。
例 2.8创建不同数值类型进行隐式转换。
2.5运算符
例 2.9 使用赋值运算符为变量赋值，实例代码如下
例2.10使用算术运算符将变量的计算结果输出
例 2.11 在循环中使用自增运算符，查看自增的效果
例 2.12 使用关系运算符对变量进行比较运算。
例2.13使用逻辑运算符和关系运算符对变量进行运算。
例2.14使用位逻辑运算符进行运算
例2.15使用位移运算符对变量进行位移运算
例2.16让byte,short两种类型的变量做无符号右移操作
2.2变量与常量
Java关键字
例 2.1 声明double型常量，并给常量赋值，使用常量进行计算。
public class Const {
public static void main(String[] args) {
final double PI =3.14; //声明常量 PI
System.out.println("常量PI的值为："+PI);
System.out.println("半径为3的圆的周长为："+(PI*2*3));
System.out.println("半径为4的圆的面积为："+(PI*4*4));
}
}
2.3基本数据类型
例2.2给int型变量按照十进制、八进制、十六进制赋值
public class Radix {
public static void main(String[] args) {
int a=11; //十进制整型
System.out.println(a);//输出十进制表示的整型值
int b=011; //八进制整型
System.out.println(b);//输出八进制表示的整型值
int c=0x11; //十六进制整型
System.out.println(c);//输出十六进制表示的整型值
}
}
例2.3 展示4.35*100的错误结果，并给出解决方案。
public class Doudle {
public static void main(String[] args) {
double a=4.35*100; //用double计算4.35*100的结果
System.out.println("a="+ a);//输出这个double值
int b= (int) a;//将double类型强制转换成int 类型
System.out.println("b="+b);//输出int 值
System.out.println("a的四舍五入值="+Math.round(a));
}
}
例2.4计算2.0-1.9的结果
public class DoubleUNAcc2 {
public static void main(String[] args){
double a=0.1;
double b=2.0-1.9;
System.out.println("a="+a);
System.out.println("b="+b);
System.out.println("a==b的结果:"+(a==b));//a==b的结果是false
/*Math.abs()是取绝对值的方法，1e-6表示1+10的-6次方，是计算机中最小数的概念
*如果两数之差的绝对值小于最小数，则认为这两个数是相等的。
*/
boolean bool =Math.abs(a-b)<(1e-6);
System.out.println("两数之差绝对值小于最下数的结果:"+bool);
}
}
2.3字符类型
转义字符
例2.5使用转义字符
public class EscapeCharacter {
public static void main(String[] args) {
char c1='\\';//反斜杠转义字符
char c2='\'';//单引号转义字符
char c3='\"';//双引号转义字符
char c4='\u2605';//051 16进制表示的字符
char c5='\101';//8进制表示字符
char c6='\n';//制表符转义字符
char c7='\t';//换行符转义字符
System.out.println("[" + c1 + "]");//输出
System.out.println("[" + c2 + "]");
System.out.println("[" + c3 + "]");
System.out.println("[" + c4 + "]");
System.out.println("[" + c5 + "]");
System.out.println("[" + c6 + "]");
System.out.println("[" + c7 + "]");
}
}布尔类型
例2.6声明boolean型变量
public class Boolean {
public static void main(String[] args) {
boolean b;//声明布尔型变量
boolean b1,b2;//声明布尔型变量b1.b2
boolean ture = false;声明布尔型变量b1赋给初值ture，b2赋给初值false，
boolean b3=ture, b4=false;
boolean b5= 2<3, b6=(2==4);
System.out.println("b5的结果是:"+b5);
System.out.println("b6的结果是:"+b6);
}
}
2.4数据类型转换
例 2.7创建不同数值类型的变量，进行隐式转换。
public class ImplicitConver {
public static void main(String[] args) {
byte mytybe =127;
int myint =150;//声明int型变量myint,并赋值150
float myfloat =452.12f;//声明float型变量myfloat,并赋值
char mychar =10; //声明char型变量mychar,并赋值
double mydouble =45.46546;//声明double型变量并赋值
float mybyte=127;
System.out.println("byte型与float型数据进行运算结果为:"+ (mybyte+myfloat));
System.out.println("byte型与int型数据进行运算结果为:"+ (mybyte*myint));
System.out.println("byte型与char型数据进行运算结果为:"+ (mybyte / mychar));
System.out.println("double型与char型数据进行运算结果为:"+ (mydouble+mychar));
}
}
例 2.8创建不同数值类型进行隐式转换。
public class EqualSign {
public static void main(String[] args) {
int a = (int)45.23;// double类型强制转int类型
long b = (long)456.6F;//float类型强long类型
char c = (char) 97.14;// double 型强制char型
System.out.println("45.23强制转换成int的结果："+a);
System.out.println("456.6F强制转换成1ong的结果："+b) ;
System.out.println("97.14强制转换成char的结果"+c);
}
}
2.5运算符
例 2.9 使用赋值运算符为变量赋值，实例代码如下
public class EqualSign1 {
public static void main(String[] args) {
int a,b,c=11;
a=32;
c=b=a+4;
System.out.println("a="+a);
System.out.println("b="+b);
System.out.println("c="+c);
}
}
例2.10使用算术运算符将变量的计算结果输出
public class Arit {
public static void main(String[] args) {
float num1 = 45.2f;
int num2 = 120;
int num3 = 17, num4=10;
System.out.println("num1+num2的和为："+(num1+ num2));
System.out.println("num1-num2的差为："+(num1- num2));
System.out.println("num1*num2的积为："+(num1*num2));
System.out.println("num1/num2的商为："+ (num1 / num2));
System.out.println("num3/num4 的余数为："+(num3 % num4));
}
}
例 2.11 在循环中使用自增运算符，查看自增的效果
public class Auto {
public static void main(String[] args) {
// TODO Auto-generated method stub
int a =1; //创建整型变量a，初始值为1
System.out.println("a="+ a);// 输出此时a的值
a++; // a自增+1
System.out.println("a++="+ a);//输出此时a的值
a++; // a自增+1
System.out.println("a++="+ a);//输出此时a的值
a++; // a自增+1
System.out.println("a++ ="+ a);//输出此时a的值
a--; // a自减-1
System.out.println("a--="+ a);//输出此时a的值
}
}
关系运算符
例 2.12 使用关系运算符对变量进行比较运算。
public class Relat {
public static void main(String[] args) {
int num1 = 4, num2 =7;
int num3 = 7;
System.out.println("num1
System.out.println("num1==num2的结果："+(num1 == num2));
System.out.println("numl!=num2的结果："+(num1=num2));
System.out.println("num1<=num2的结果："+(num1<= num2));
System.out.println("num2>=num3的结果："+(num2 >= num3)); }
}
例2.13使用逻辑运算符和关系运算符对变量进行运算。
public class Logical {
public static void main(String[] args) {
int a=2;声明int型变量a
int b= 5; // 声明int型变量b
//声明boolean型变量，用于保存应用逻辑运算符“&&”后的返回值
boolean result=((a>b) &&(a!=b));
//声明boolean型变量，用于保存应用逻辑运算符“||”后的返回值
boolean result2=((a>b) ||(a!=b));
System.out.println(result); 将变量result输出
System.out.println(result2); 将变量result2输出
}
}
例2.14使用位逻辑运算符进行运算
public class Logical1 {
public static void main(String[] args) {
short x=-123; //创建short变量x， 等于123取反的值
System.out.println("12与8的结果为:"+(12&8)); //位逻辑或计算整数的结果
System.out.println("4或8的结果为:"+(4|8)); //位逻辑或计算整数的结果
System.out.println("31异或22:"+(31^22)); //位逻辑异或计算整数的结果
System.out.println("123取反结果为:"+x); //位逻辑取反结果计算布尔值的结果
System.out.println("2>3与4！=7的与结果:"+(2>3&4!=7));//位逻辑与计算布尔值的结果
System.out.println("2>3与4！=7的或结果:"+(2>3|4!=7));//位逻辑或计算布尔值的结果
System.out.println("2>3与4！=7的与异或结果:"+(2<3^4!=7));
//位逻辑异或计算布尔值的结果
}
}
例2.15使用位移运算符对变量进行位移运算
public class Bitwise2 {
public static void main(String[] args) {
int a=24;
System.out.println(a+"右移两位的结果是:"+(a>>2));
int b=-16;
System.out.println(b+"右移两位的结果是:"+(b<<3));
int c=-256;
System.out.println(c+"无符号右移两位的结果是:"+(c>>>2));
}
}
例2.16让byte,short两种类型的变量做无符号右移操作
public class Bitwise3 {
public static void main(String[] args) {
byte a=(byte) (-32>>>1);
System.out.println("byte无符号右移的结果:"+a);
short b=(short) (-123>>>4);
System.out.println("short无符号右移的结果:"+b);
}
}
1.标识符：用来标识类名、变量名、方法名、数组名、文件名的有效字符序列
由任意顺序字母（A/a）、下划线（-）、美元符号（＄）和数字（不能放开头）组成。
.只能包含字母、下划线、美元符号、数字
.不能以数字开头
.要避开关键字（关键字即为代码中彩色的字）这里用任意代码作为示例
2.变量：变化的
定义和赋值：类型+变量名 例如：（double+weight）
.局部变量：在方法内部定义，只在该方法内有效
.成员变量：在类里在方法外，在整个类和方法里有效
public class Thirdtwo {
static int times=3;//成员变量
public static void main(String[] args) {
int times=4;//局部变量
System.out.println("times的值为："+times);//当局部变量和成员变量名字相同使用就近原则
}
}
//将局部变量删除就会输出成员变量的值或者将成员变量输出
上段代码结果为：
public class Thirdtwo {
static int times=3;//成员变量
public static void main(String[] args) {
int times=4;//局部变量
System.out.println("times的值为：);//当局部变量和成员变量名字相同使用就近原则
System.out.println("Thirdtwo.times")//类+times
}//如果将类times删掉的话输出就会报错
}
//将局部变量删除就会输出成员变量的值或者将成员变量输出
上段代码结果为：
常量：固定的
public class ThirdPart {
public static void main(String[] args) {
final int number;//定义一个int类型number数字
number=1125;
System.out.println(number);
}
}
重新赋值，使之报错（错误为红色部分）
（final是特殊的变量）
在成员变量中定义常量
public class ThirdPart {
static final double PI =3.14;
public static void main(String[] args) {
final int number;//定义一个int类型number数字 //static为静态
number=1125;
System.out.println(number);
System.out.println(PI);
}
1.赋值运算符
以“=”表示，将右边数赋值给左边
public class Eval {
public static void main(String[] args) {
// TODO Auto-generated method stub
int a,b,c;
a = 15;
c=b = a+4;
System.out.println("c值为："+c);//例题3.7
System.out.println("b值为："+b);
//c=b=a+4;//从右往左看，一般是b=a+4；c=a；
}
}
2.算术运算符
Java算数运算符
运算符 说明 实例 结果
+ 加 12.45f+15 27.45
- 减 4.56-0.16 4.4
* 乘 5L*12.45f 62.25
/ 除 7/2 3
% 取余 12%10 2
import java.util.Scanner;//例题3.8
public class Eval {
public static void main(String[] args) {
Scanner sc =new Scanner(System.in);
System.out.println("请输入两个数字，用空格隔开（num1 num2）:");
double num1=sc.nextDouble();//可以改为int类型
double num2=sc.nextDouble();
System.out.println("num1+num2的和为："+(num1+ num2));
System.out.println("num1-num2的差为："+(num1-num2));
System.out.println("num1*num2的积为："+(num1* num2));
System.out.println("num1/num2的商为："+(num1/ num2));
System.out.println("num%num2的余数为："+(num1% num2));
sc.close();
}
}
自增和自减
a++，++a；a--，--a；（运算符在前，先运算后使用；运算符在后，先使用后运算）；
关系运算符
比较运算符
运算符 作用 举例 操作数据 结果
> 比较左方是否大于右方 ‘a’>'b' 整形、浮点型、字符型
false
< 比较左方是否小于右方 156<456 整形、浮点型、字符型 true
=
比较左方是否等于右方 'c'='c' 基本数据类型、引用型 true
>= 比较左方是否大于等于右方 479>=426 整形、浮点型、字符型 true
<= 比较左方是否小于等于右方 12.45<=45.5 整形、浮点型、字符型 true
!= 比较左方是否不等于右方 'y'!='t' 基本数据类型、引用型 true
public class Compare {
public static void main(String[] args) {
// TODO Auto-generated method stub
int number1=4;
int number2=5;
System.out.println("number1 > number2的返回值为："+(number1 > number2));
System.out.println("number1 < number2的返回值为："+(number1 < number2));
System.out.println("number1 == number2的返回值为："+(number1 == number2));
System.out.println("number1 != number2的返回值为："+(number1 != number2));
System.out.println("number1 >= number2的返回值为："+(number1 >= number2));
System.out.println("number1 <= number2的返回值为："+(number1 <= number2));//例题3.9
}
}
逻辑运算符
&&（与）:两者都为真，结果才是真；
||（或）：只要有一者为真，结果就是真；
！（非）：非真即假，非假即真；
false&&.....&&.....:结果一定为false(短路现象)
true||.....||.....:结果一定为true（短路现象）
位运算符
二进制之间进行运算使用位运算符
&（与）：两者都为1，结果才是1；
|（或）：只要有一者为1，结果就是1；
~（取反）：0变1，1变0；
^(异或)：两者相同即为0，不同为1；
位移运算符
<<(左移):整体往左移一位，空位补0，溢出去掉。
>>(右移)：整体往右移一位，正数补0，负数补1，溢出去掉。
>>>(无符号右移)：整体往右移，空位补0，溢出去掉。
三元运算符
例如：A？B：C
A:一定是一个条件语句
B：A为真结果为B
C：A为假结果为C
int a=3；
int b=a>2? a++/a--/++a：8；
a=4；b=3 / a=2 b=4 /a=4 b=4
转换if else语句：if(a>2）{
b=a++/a--/}
else{
b=8}
第五章数组
5.2一维数组：点
数组简单的认为是很多格子
5.2.1如何去定义数组：上面先括号+数组名比较常用
5.2.2 分配内存并进行初始化
怎么对元素进行赋值，a中有三个元素
错误：数组下标越界，超出赋值长度
解决方法：重新赋值分配a，或者将多赋值删掉，注意for循环里条件
（或者用a.length）/（for循环，注意冒号）
1.
2.
public class Fiveone {
public static void main(String[] args) {
// TODO Auto-generated method stub
//申明一维数组
int[] a;//先括号在加数组名
char b[];//先数组名在加括号
//分配内存
a =new int[4];//需要的内存
//分配内存的同时进行初始化值
b = new char[] {'a','b','c'};//给b分配3个内存
a[0]=1;//给a中元素赋值
a[1]=2;//a中有三个元素
a[2]=3;
a[3]=4;
//数组的遍历，数组的长度是几个i<几
for(int i=0;i
System.out.println(temp);
}
for(int temp : a) {
System.out.println(temp);
}//for循环遍历数组 5.4.1
}
}
public class Fiveone {
public static void main(String[] args) {
// TODO Auto-generated method stub
//申明一维数组
int[] a;//先括号在加数组名
char b[];//先数组名在加括号
//分配内存
a =new int[4];//需要的内存
//分配内存的同时进行初始化值
b = new char[] {'a','b','c'};//给b分配3个内存
/*a[0]=1;//给a中元素赋值
a[1]=2;//a中有三个元素
a[2]=3;
a[3]=4;*/
b[0]='a';
b[1]='b';
b[2]='c';
//数组的遍历，数组的长度是几个i<几
for(int i=0;i
System.out.println(temp);
}
for(char temp : b) {//冒号隔开，前：数据类型；后：数组名
System.out.println(temp);
}//for循环遍历数组
}
}
5.3.1：二维数组 ：面
单个格子赋值
public class Fiveone {
public static void main(String[] args) {
//申明二维数组
int[] [] a;
char b[] [];//地址指向另一个数组
//分配内存
a =new int[4][3];//4列3行
b = new char[][] {{'z','h'},{'h','z'},{'h','z','d'}};//2*2,这时就会变成3*3
//分配内存的同时进行初始化值
a[0]=new int[] {1,2,3};
a[1]=new int[] {4,5,6};
a[2]=new int[] {7,8,9};
a[3][0] =10;
a[3][1] =11;//给单个格子赋值
a[3][2] =12;
for(int i=0;i
for(int j=0;j
System.out.println(temp[j]);
}
System.out.println();
}
for(char[] temp : b) {//冒号隔开，前：数据类型；后：数组名
for(char c:temp ) {//再次遍历
System.out.println(c);
}
System.out.println();
}//for循环遍历数组
}
}
例题5.1
public class GetDay {
public static void main(String[] args) {
// TODO Auto-generated method stub
int day[]=new int[] {31,28,31,30,31,30,31,31,30,31,30,30
};
for(int i=0;i<12;i++) { //循环
System.out.println((i+1)+"月有"+day[i]+"天"); //输出每有天数
}
}
}
例题5.2
public class Ma { //创建类
public static void main(String[] args) { //主方法
// TODO Auto-generated method stub
int a[][] = new int[3][4]; //创建二维数组
for(int i = 0;i
}
System.out.println(); //输出空格
}
}
}
例题5.3
public class Ta {
public static void main(String[] args) {
// TODO Auto-generated method stub
int b[][] = new int[][] {{1},{2,3},{4,5,6}}; //定义二维数组
for(int k=0;k
}
System.out.println(); //输出空格
}
}
}
5.4：数组的基本操作
例题5.4
public class Tautog {
public static void main(String[] args) {
// TODO Auto-generated method stub
int arr2[][]= {{4,3},{1,2}}; //定义二维数值赋初始值
System.out.println("数组中的元素：");//输出值
int i=0; //外层循环计数器变量，赋值为零
for(int x[]:arr2) { //外层循环变量变一维数组 for循环
i++;
int j=0;
for(int e:x) { //内层循环计数器变量
j++;
if(i==arr2.length&&j==x.length) { //判断变量是二维数组中的最后一个元素，第二行第二列数字输出
System.out.print(e); //输出二位数组最后一个元素，优化判断
}else //如果不是
System.out.print(e+"、"); //输出
}
}
}
}
5.4.2：填充替换数组元素
数组中的元素定义完成后，可通过Arrays类的静态方法fill（）对数组中元素进行替换
Arrays.fill（数组名，值）；
例题5.5
import java.util.Arrays;
public class Fivetwo {
public static void main(String[] args) {
// TODO Auto-generated method stub
int arr[] =new int[5];//创建int数组
Arrays.fill(arr, 9);//使用同一个值进行填充，最后输出为9
for(int i=0;i
System.out.println("第"+i+"个元素是："+arr[i]);//将元素输出
}
}
}//例题5.5
替换数组的部分元素（前索引值改后索引值不改）
Arrays.fill（数组名，前索引，后索引，值）；前索引和后索引的值
例题5.6
import java.util.Arrays;
public class Fivetwo {
public static void main(String[] args) {
// TODO Auto-generated method stub
int arr[] =new int[] {45,12,2,10};//创建int数组
Arrays.fill(arr, 1,2,8);//使用fill静态替换指定范围内的元素
for(int i=0;i
System.out.println("第"+i+"个元素是："+arr[i]);//将元素输出
}
}
}//例题5.6
按住ctrl键查看fill源码
5.4.3：对数组进行排序
Arrays.soft（数组名）
例题5.7
import java.util.Arrays;
public class Fivetwo {
public static void main(String[] args) {
// TODO Auto-generated method stub
int arr[] =new int[] {23,42,12,8};//创建int数组
Arrays.sort(arr);//使用sort进行排序
for(int i=0;i
System.out.println(arr[i]);//将元素输出
}
}
}//例题5.7
5.4.4：复制数组（空位补0，溢出去掉）
新数组名= Arrays.copyOf（旧的数组名，新数组长度）；多种重载形式，类型多样
import java.util.Arrays;
public class Fivetwo {
public static void main(String[] args) {
// TODO Auto-generated method stub
int arr[] =new int[] {23,42,12};//创建int数组
int newarr[]=Arrays.copyOf(arr,5);//创建新的数组并复制，长度有五位
for(int i=0;i
System.out.println(newarr[i]);//将新元素输出
}
}
}//例题5.8
当新数组长度为五，比旧的数组长，空位补零
当新数组长度为二，比旧的数组短，取该有的位置，溢出去掉，按顺序去掉
import java.util.Arrays;
public class Fivetwo {
public static void main(String[] args) {
// TODO Auto-generated method stub
int arr[] =new int[] {23,42,12};//创建int数组
int newarr[]=Arrays.copyOf(arr,2);//创建新的数组并复制
for(int i=0;i
System.out.println(newarr[i]);//将新元素输出
}
}
}//例题5.8
5.4.4.2复制数组的部分元素 copyOfRange（的数组名，前索引，后索引，新数组长度）；
import java.util.Arrays;//导入java..Arrays
public class Fivetwo {
public static void main(String[] args) {
// TODO Auto-generated method stub
int arr[] =new int[] {23,42,12,84,10};//创建int数组
int newarr[]=Arrays.copyOfRange(arr,0,3);//创建新的数组并复制
for(int i=0;i
System.out.println(newarr[i]);//将新元素输出
}
}
}//例题5.9
5.4.5：查询数组（先排序后查询）
索引=Arrays.binarySearch(数组名，元素)；
import java.util.Arrays;//导入java..Arrays
public class Fivetwo {
public static void main(String[] args) {
// TODO Auto-generated method stub
int ia[] =new int[] {1,8,9,4,5};//创建int数组
Arrays.sort(ia);//数组排序
int index = Arrays.binarySearch(ia, 4);//查找4的位置
System.out.println("4的索引位置是："+index);//将索引输出
}
}
//例题5.10
数组如果不进行排序
索引值会变成负数
5.4.5.2（前索引含后索引不含）
索引=Arrays.binarySearch(数组名，前索引，后索引，元素)；
例题5.11
import java.util.Arrays;//导入java.utill.Arrays
public class Fivetwo {
public static void main(String[] args) {
String str[]=new String []{"ab","cd","ef","yz"};//创建str数组
Arrays.sort(str);//数组排序
int index = Arrays.binarySearch(str,0,2,"cd");//查找cd的位置
System.out.println("cd的索引位置是："+index);//将索引输出
}
}
//例题5.11
前索引可以找到在区间内
import java.util.Arrays;//导入java.utill.Arrays
public class Fivetwo {
public static void main(String[] args) {
String str[]=new String []{"ab","cd","ef","yz"};//创建str数组
Arrays.sort(str);//数组排序
int index = Arrays.binarySearch(str,0,2,"ab");//查找cd的位置
System.out.println("ab的索引位置是："+index);//将索引输出
}
}
//例题5.11
后索引不包含在区间
import java.util.Arrays;//导入java.utill.Arrays
public class Fivetwo {
public static void main(String[] args) {
String str[]=new String []{"ab","cd","ef","yz"};//创建str数组
Arrays.sort(str);//数组排序
int index = Arrays.binarySearch(str,0,2,"ef");//查找cd的位置
System.out.println("ef的索引位置是："+index);//将索引输出
}
}
//例题5.11
5.5 数组排序算法
5.5.1冒泡排序
它排序数组元素的过程总是在将小的数往上放，较大的竖往后放类似于水中气泡往上升的动作，所以称为冒泡排序。
5.5.2、直接排序
选择排序也叫直接排序，它的排序速度比冒泡排序要快一些。
5.5.3、反转排序
就是以相反的排序，把原有的数组内存重新排序。反转排序的基本思想比较简单，把数组的最后1个元素和第1个元素替换，倒数第2个元素与第2个元素替换，以此类推。