总结小知识
面试
- p312-11.30 java三大特性
书写规范
1字符=2字节
1字节=8bit(由0，1组成)
println（" "）只能用双引号
char a=‘c’ 只能用单引号
重点
2.
3.调用length的方式
快捷键
syso+alt+/ 自动补齐System.out.println()
ctrl+shif+f 代码规范化
ctrl+shif+o 导入包
小语句
1.跳出死循环
//法1
while(true){
break;
}
//法2
boolean isFlag=true
while(isFlage){
if(){
isFlag=false}
}
for(;;;){
break;}
2.计时
long start = System.currentTimeMillis();//获取当前时间距离1970-01-01 00：00：00的毫秒
3.快速进入命令窗口
4.换行，制表符
System.out.print("\n");
System.out.print("\t\t");//直接两制表符
5.String a +=变量
6.遍历获取最大值
int maxScore=0;
for(int i =0;i<num;i++){
if (scoreArr[i]>=maxScore){
maxScore=scoreArr[i];
}
}
基本语法
HelloWorld
数据类型
1.变量要附上数据类型
进制说明
进制转换
标识符规范
char c1=5 :5表示真正的数字5
char c1=‘5’ :'5’表示的是ascll码中的存储，对应的输出是53
char c1=‘a’ :输出97
运算符
1.算术运算符
s1++自增1开发效率高，变量都是同一个类型
同样
short s1=10;
s1+=2也可以通过，不改变变量数据类型
s1 =s1+2这里就是编译错误，因为没有s1没有定义int型
2.逻辑运算符
3.位运算
全补0，或全补1
3.三元运算符
程序流程控制
顺序+分支+循环
分支
1.if-else
若if后只有一行，可将作用域的{}去掉，但只能执行一行，但为了规范还是写上的好！
2.分支switch-case
scanner只能获取字符串，需要。charAt（0）来获取
判断学生是否及格，因为case之后是常量不能是范围，所以只能用除法来减少case的个数，如下
循环
**
a.开发中常使用for，while
b.do{}while ();至少执行一次循环体
1.初始化条件
2.循环条件
3.循环体
4.迭代部分
**
1.for
2.while
3.do-while
嵌套循环（应用）
乘法表
素数（法一）
素数（法二）
特征关键字的使用(break,continue)
Project1（支出系统）
难点1：使用String +操作来存储信息
难点2：case1中定义的变量a，case2中不能重新定义a，因为case1没有break的话，则case1,case2共享函数，造成冲突。
import java.util.Scanner;
class Test
{public static void main(String [] args){
boolean isFlag=true;
int sumMoney = 10000;
String details="收支\t账户金额\t收支金额\t说 明\n";//这个要放到case外。用String类型通过加减方式来存储数据
while(isFlag){
System.out.println("----------------家庭收支记账软件---------------");
System.out.println();
System.out.println("\t"+"\t"+"1 收支明细");
System.out.println("\t"+"\t"+"2 登记收入");
System.out.println("\t"+"\t"+"3 登记支出");
System.out.println("\t"+"\t"+"4 退 出");
System.out.print("\t"+"\t"+"请选择(1-4) :");
Scanner scan =new Scanner(System.in);
int selectNumber = scan.nextInt();
//System.out.print(selectNumber);
System.out.println();
switch (selectNumber)
{
case 1:
System.out.println("------------------当前收支记录-----------------");
System.out.println(details);
System.out.println("-----------------------------------------------");
break;
case 2:
System.out.print("本次收入金额 : ");
int inMoney = scan.nextInt();
System.out.print("本次收入说明 : ");
String info1 = scan.next();
sumMoney+=inMoney;
details+="收入\t"+sumMoney+"\t\t"+inMoney+"\t\t"+info1+"\n";
break;
case 3:
System.out.print("本次支出金额 : ");
int outMoney = scan.nextInt();
System.out.print("本次支出说明 : ");
String info2 = scan.next();
sumMoney-=outMoney;
details+="支出\t"+sumMoney+"\t\t"+outMoney+"\t\t"+info2+"\n";
break;
case 4:
System.out.print("确认是否退出(Y/N) :");
char quit = scan.next().charAt(0);//case中不能共享同一个变量
if (quit=='Y')
{isFlag=false;
}
break;
default:
System.out.print("输入错误，请重新输入:" );
break;
}
}
}
}
数组Array
数据在内存中分配的是个连续空间
一维、多维数组学习要求
一维数组
import java.util.Scanner;
public class Array {
public static void main(String[] args) {
System.out.print("请输入学生人数：");
Scanner scan =new Scanner(System.in);
int num = scan.nextInt();
System.out.println("请输入"+num+"个成绩：");
int[] scoreArr=new int[num];
for (int i=1;i<=num;i++){
int score =scan.nextInt();
scoreArr[i-1]=score;
}
//遍历获取最大值
int maxScore=0;
for(int i =0;i<num;i++){
if (scoreArr[i]>=maxScore){
maxScore=scoreArr[i];
}
}
for(int i =0;i<=num-1;i++){
String dengji;
if (scoreArr[i]>=maxScore-10){
dengji="A";
}
else if (scoreArr[i]>=maxScore-20){
dengji="B";
}
else if (scoreArr[i]>=maxScore-30){
dengji="C";
}
else {
dengji="D";
}
System.out.print("student "+i+" score is "+scoreArr[i]+" grade is "+dengji+"\n");
}
}
}
多维数组
Class Arrays
//1.boolean equals(int[] a,int[] b):判断两个数组是否相等。
int[] arr1 = new int[]{1,2,3,4};
int[] arr2 = new int[]{1,3,2,4};
boolean isEquals = Arrays.equals(arr1, arr2);
System.out.println(isEquals);
//2.String toString(int[] a):输出数组信息。
System.out.println(Arrays.toString(arr1));
//3.void fill(int[] a,int val):将指定值填充到数组之中。
Arrays.fill(arr1,10);
System.out.println(Arrays.toString(arr1));
//4.void sort(int[] a):对数组进行排序。
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));
//5.int binarySearch(int[] a,int key)
int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
int index = Arrays.binarySearch(arr3, 210);
数组常见异常
arrary复习
面向对象（上）
类就是汽车图纸，对象就是类的实例化=红旗
重点
类的属性(成员变量) vs局部变量
package com.atguigu.java;
/*
* 类中属性的使用
*
* 属性（成员变量） vs 局部变量
* 1.相同点：
* 1.1 定义变量的格式：数据类型 变量名 = 变量值
* 1.2 先声明，后使用
* 1.3 变量都有其对应的作用域
*
*
* 2.不同点：
* 2.1 在类中声明的位置的不同
* 属性：直接定义在类的一对{}内
* 局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
*
* 2.2 关于权限修饰符的不同
* 属性：可以在声明属性时，指明其权限，使用权限修饰符。
* 常用的权限修饰符：private、public、缺省、protected --->封装性
* 目前，大家声明属性时，都使用缺省就可以了。
* 局部变量：不可以使用权限修饰符。
*
* 2.3 默认初始化值的情况：
* 属性：类的属性，根据其类型，都有默认初始化值。
* 整型（byte、short、int、long）：0
* 浮点型（float、double）：0.0
* 字符型（char）：0 （或'\u0000'）
* 布尔型（boolean）：false
*
* 引用数据类型（类、数组、接口）：null
*
* 局部变量：没有默认初始化值。
* 意味着，我们在调用局部变量之前，一定要显式赋值。
* 特别地：形参在调用时，我们赋值即可。
*
* 2.4 在内存中加载的位置：
* 属性：加载到堆空间中 （非static）
* 局部变量：加载到栈空间
*
*/
public class UserTest {
public static void main(String[] args) {
User u1 = new User();
System.out.println(u1.name);
System.out.println(u1.age);
System.out.println(u1.isMale);
u1.talk("韩语");
u1.eat();
}
}
class User{
//属性（或成员变量）
String name;
public int age;
boolean isMale;
public void talk(String language){//language:形参，也是局部变量
System.out.println("我们使用" + language + "进行交流");
}
public void eat(){
String food = "烙饼";//局部变量
System.out.println("北方人喜欢吃：" + food);
}
}
类的方法
/*
* 类中方法的声明和使用
*
* 方法：描述类应该具有的功能。
* 比如：Math类：sqrt()\random() \...
* Scanner类：nextXxx() ...
* Arrays类：sort() \ binarySearch() \ toString() \ equals() \ ...
*
* 1.举例：
* public void eat(){}
* public void sleep(int hour){}
* public String getName(){}
* public String getNation(String nation){}
*
* 2. 方法的声明：权限修饰符 返回值类型 方法名(形参列表){
* 方法体
* }
* 注意：static、final、abstract 来修饰的方法，后面再讲。
*
* 3. 说明：
* 3.1 关于权限修饰符：默认方法的权限修饰符先都使用public
* Java规定的4种权限修饰符：private、public、缺省、protected -->封装性再细说
*
* 3.2 返回值类型： 有返回值 vs 没有返回值
* 3.2.1 如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用
* return关键字来返回指定类型的变量或常量：“return 数据”。
* 如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不需要
* 使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。
*
* 3.2.2 我们定义方法该不该有返回值？
* ① 题目要求
* ② 凭经验：具体问题具体分析
*
* 3.3 方法名：属于标识符，遵循标识符的规则和规范，“见名知意”
*
* 3.4 形参列表： 方法可以声明0个，1个，或多个形参。
* 3.4.1 格式：数据类型1 形参1,数据类型2 形参2,...
*
* 3.4.2 我们定义方法时，该不该定义形参？
* ① 题目要求
* ② 凭经验：具体问题具体分析
*
* 3.5 方法体：方法功能的体现。
*
* 4.return关键字的使用：
* 1.使用范围：使用在方法体中
* 2.作用：① 结束方法
* ② 针对于有返回值类型的方法，使用"return 数据"方法返回所要的数据。
* 3.注意点：return关键字后面不可以声明执行语句。
*
* 5. 方法的使用中，可以调用当前类的属性或方法
* 特殊的：方法A中又调用了方法A:递归方法。
* 方法中，不可以定义方法。
*/
public class CustomerTest {
public static void main(String[] args) {
Customer cust1 = new Customer();
cust1.eat();
//测试形参是否需要设置的问题
// int[] arr = new int[]{3,4,5,2,5};
// cust1.sort();
cust1.sleep(8);
}
}
//客户类
class Customer{
//属性
String name;
int age;
boolean isMale;
//方法
public void eat(){
System.out.println("客户吃饭");
return;
//return后不可以声明表达式
// System.out.println("hello");
}
public void sleep(int hour){
System.out.println("休息了" + hour + "个小时");
eat();
// sleep(10);
}
public String getName(){
if(age > 18){
return name;
}else{
return "Tom";
}
}
public String getNation(String nation){
String info = "我的国籍是：" + nation;
return info;
}
//体会形参是否需要设置的问题
// public void sort(int[] arr){
//
// }
// public void sort(){
// int[] arr = new int[]{3,4,5,2,5,63,2,5};
// //。。。。
// }
public void info(){
//错误的
// public void swim(){
//
// }
}
}
理解万物皆对象 （p202）
基本数据类型的初始化符合之前的定义
引用数据类型只存储null，或地址
所以上面类的属性初始化还是0，0，0
匿名对象
方法补充
重载
两同一不同”:同一个类、相同方法名;参数列表不同。
可变形参个数
当不确定输入有多少个值的时候，之前存放同一类元素(整形，boolean，对象)时，用的是arrary，现在用String …strs，两者其实是一样的
方法参数的值传递机制
1.基本的传参
2. 行参的传参过程
总结：传的是基本数据类型，在main函数中，数据是不会被方法修改的（由于方法函数的释放）
传的是引用数据类型，在main函数中，main函数中的变量也发生修改的（由于方法函数共用一个变量的地址）
练习内存解析（P213）
方法之递归
小技巧
- 已知条件的index<n,则让f(n-1)函数index逐渐减小
- f(n)=f(n-1)+f(n-2)等式右有两个函数，意味着要初始化两个已知条件
//斐波那契
public static int feiBo(int n){
if (n==1 |n==2 ){
return 1;
}
else{
return feiBo(n-1)+feiBo(n-2);
}
}
}
面向对象-封装与隐藏
二、封装性的体现：
* 我们将类的属性xxx私有化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值
*
* 拓展：封装性的体现：① 如上 ② 不对外暴露的私有的方法 ③ 单例模式 ...
*
*
* 三、封装性的体现，需要权限修饰符来配合。
* 1.Java规定的4种权限（从小到大排列）：private、缺省、protected 、public
* 2.4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
* 3.具体的，4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
* 修饰类的话，只能使用：缺省、public
*
* 总结封装性：Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小
构造器（只能重载不能重写）
关键字
1.this
2.package
3.import
UML类图
银行客户题
package com.atguigu.java;
public class Test8 {
public static void main(String [] args){
Bank bank =new Bank();
System.out.println(bank.getNumOfCustomers());
//1.开个户名
bank.addCustomer("lin", "yang");
Customer cust=bank.getCustomer(0);
System.out.println(cust.getFirstName());
System.out.println(cust.getLastName());
//2.把这卡给这个开户的人
Account account = new Account(10000.00);//对象就要加new，不然它会当成 method，The method Account(double) is undefined for the type Test8
cust.setAccount(account);//或者cust.setAccount(new Account(10000.00))
bank.getCustomer(0).getAccount().withdraw(200);
bank.getCustomer(0).getAccount().deposit(50.00);
System.out.println(account.getBalance());
//3.查看这个人的信息
System.out.println("查看这个人的信息");
System.out.println(cust.getFirstName()+cust.getLastName());
cust.getAccount().getBalance();
//3.1再来一个客户
bank.addCustomer("xiao", "wang");
//4.一开始开辟10个空间，查看 此时银行里共有多少个用户.
System.out.println("一开始开辟10个空间，查看此时银行里共有多少个用户.");
System.out.println(bank.getNumOfCustomers());
}
}
class Account{
private double balance;
public Account(double init_balance){
balance = init_balance;
}
public double getBalance(){
System.out.println("账户金额"+balance);
return this.balance;
}
public void deposit(double amt){
System.out.println("存入金额"+amt);
this.balance +=amt;
}
public void withdraw(double amt){
if(this.balance>=amt){
System.out.println("取出金额"+amt);
this.balance -=amt;
}else{System.out.println("总金额为："+this.balance+"不够取出 ！");}
}
}
class Customer{
private String firstName;
private String lastName;
private Account account;
public Customer(){
}
public Customer(String f,String l){
firstName=f;
lastName = l;
}
public String getFirstName(){
return firstName;
}
public String getLastName(){
return lastName;
}
public void setAccount(Account acct){
this.account = acct;
}
public Account getAccount(){
return account;
}
}
class Bank{
private Customer[] customers;
private int numberOfCustomers;
public Bank(){
customers =new Customer[10];
}
public void addCustomer(String f,String l){
Customer cust = new Customer(f,l);
customers[numberOfCustomers]=cust;
numberOfCustomers+=1;
}
public int getNumOfCustomers(){
return this.numberOfCustomers;
}
public Customer getCustomer(int index){
return customers[index];
}
}
面向对象（中）
向上转型就是多态(形参列表是父类，调用时是子类)
向下转型就是调用子类信息（将父类强转成子类）
重写（override/overwrite）
super
多态
下面已验证
//p2是父类，man是子类
Person p2 =new Man();
p2.eat()
使用向下转型，先if(a instanceof A){}否则抛出异常
Object类的使用
object为所有对象的父类，object有的方法，其子类也有
equals()/ toString()/ getClass()
.equals()和==的区别
总结：在调用object.equal没有改写的情况下，equal（）函数返回的是a == b, ''也就是说和==是一样的
改写后，比较两个对象的实体内容（仅仅针对的是属性-已验证）是否相同
/*
* 面试题： == 和 equals() 区别
* 一、回顾 == 的使用：
* == ：运算符
* 1. 可以使用在基本数据类型变量和引用数据类型变量中
* 2. 如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。（不一定类型要相同）
* 如果比较的是引用数据类型变量：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
* 补充： == 符号使用时，必须保证符号左右两边的变量类型一致。
*
* 二、equals()方法的使用：
* 1. 是一个方法，而非运算符
* 2. 只能适用于引用数据类型
* 3. Object类中equals()的定义：
* public boolean equals(Object obj) {
return (this == obj);
}
* 说明：Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
*
* 4. 像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是
* 两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。
*
* 5. 通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体内容"是否相同。那么，我们
* 就需要对Object类中的equals()进行重写.
* 重写的原则：比较两个对象的实体内容（针对的是属性）是否相同.
*/
public class EqualsTest {
public static void main(String[] args) {
//基本数据类型
int i = 10;
int j = 10;
double d = 10.0;
System.out.println(i == j);//true
System.out.println(i == d);//true
boolean b = true;
// System.out.println(i == b);
char c = 10;##这个10是数值型的10，不是存储的ascll，c=‘1’加引号的才是
System.out.println(i == c);//true
char c1 = 'A';
char c2 = 65;
System.out.println(c1 == c2);//true
//引用类型：
Customer cust1 = new Customer("Tom",21);
Customer cust2 = new Customer("Tom",21);
System.out.println(cust1 == cust2);//false
String str1 = new String("atguigu");
String str2 = new String("atguigu");
System.out.println(str1 == str2);//false
System.out.println("****************************");
System.out.println(cust1.equals(cust2));//false
System.out.println(str1.equals(str2));//true
Date date1 = new Date(32432525324L);
Date date2 = new Date(32432525324L);
System.out.println(date1.equals(date2));//true
toString()
包装类（wrapper）
package day13;
public class test {
public static void main(String [] args){
//基本数据类型->包装类，可以调用object的类
//a.创建包装类的标准格式
Integer in1 =new Integer(3);
System.out.println(in1.toString());
//1.自动装箱
Integer in2 =3;
Boolean b1= true;
//2.自动拆箱
int num1 = in1;
boolean b2 =b1;
//String类型 --->基本数据类型、包装类：调用包装类的parseXxx(String s)
String str1 = "123";
int num2 = Integer.parseInt(str1);
String str2 = "true1";
boolean b3 = Boolean.parseBoolean(str2);
System.out.println(b3);
//基本数据类型、包装类--->String类型：调用String重载的valueOf(Xxx xxx)
int num11 = 10;
//方式1：连接运算
String str11 = num11 + "";
//方式2：调用String的valueOf(Xxx xxx)
float f1 = 12.3f;
String str21 = String.valueOf(f1);//"12.3"
System.out.println(str21);
}
}
经典习题
数组中的问题
1.杨辉三角
public class Array {
public static void main(String[] args) {
int[][] yangHui=new int[10][];
//初始化数组
for (int i =0;i<10;i++){
yangHui[i]=new int[i+1];
}
//首尾赋1
for (int i =0;i<10;i++){
yangHui[i][0]=1;
yangHui[i][i]=1;
}
//中间赋值
for(int i =2;i<10;i++){
for(int j=1;j<yangHui[i].length-1;j++){
yangHui[i][j]=yangHui[i-1][j]+yangHui[i-1][j-1];
}
}
//遍历查看
for (int i=0;i<10;i++){
for(int j=0;j<yangHui[i].length;j++){
System.out.print(yangHui[i][j]+" ");
}
System.out.println();
}
}
}
2.生成指定范围随机数
//Math.random():[0.0, 1)
//范围-[10,20]
int a=(int) (Math.random()*(20-10+1)+10);
System.out.print(a);
3.求最大最小(用max变量来接收)
int max=arr1[0] 不能直接=0，如果输入全是负的就会有问题
/*
* 算法的考查：求数值型数组中元素的最大值、最小值、平均数、总和等
*
* 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
* 然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
* 要求：所有随机数都是两位数。
*
* [10,99]
* 公式：(int)(Math.random() * (99 - 10 + 1) + 10)
*
*/
public class ArrayTest1 {
public static void main(String[] args) {
int[] arr = new int[10];
for(int i = 0;i < arr.length;i++){
arr[i] = (int)(Math.random() * (99 - 10 + 1) + 10);
}
//遍历
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + "\t");
}
System.out.println();
//求数组元素的最大值
int maxValue = arr[0];
for(int i = 1;i < arr.length;i++){
if(maxValue < arr[i]){
maxValue = arr[i];
}
}
System.out.println("最大值为：" + maxValue);
//求数组元素的最小值
int minValue = arr[0];
for(int i = 1;i < arr.length;i++){
if(minValue > arr[i]){
minValue = arr[i];
}
}
System.out.println("最小值为：" + minValue);
//求数组元素的总和
int sum = 0;
for(int i = 0;i < arr.length;i++){
sum += arr[i];
}
System.out.println("总和为：" + sum);
//求数组元素的平均数
int avgValue = sum / arr.length;
System.out.println("平均数为：" + avgValue);
}
}
4.数组的复制、反转、查找(线性查找、二分法查找)
/*
* 算法的考查：数组的复制、反转、查找(线性查找、二分法查找)
*
*
*/
public class ArrayTest2 {
public static void main(String[] args) {
String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};
//数组的复制(区别于数组变量的赋值：arr1 = arr)
String[] arr1 = new String[arr.length];
for(int i = 0;i < arr1.length;i++){
arr1[i] = arr[i];
}
//数组的反转
//方法一：
// for(int i = 0;i < arr.length / 2;i++){
// String temp = arr[i];
// arr[i] = arr[arr.length - i -1];
// arr[arr.length - i -1] = temp;
// }
//方法二：
// for(int i = 0,j = arr.length - 1;i < j;i++,j--){
// String temp = arr[i];
// arr[i] = arr[j];
// arr[j] = temp;
// }
//遍历
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + "\t");
}
System.out.println();
//查找（或搜索）
//线性查找：直接for循环
String dest = "BB";
dest = "CC";
boolean isFlag = true;
for(int i = 0;i < arr.length;i++){
if(dest.equals(arr[i])){
System.out.println("找到了指定的元素，位置为：" + i);
isFlag = false;
break;
}
}
if(isFlag){
System.out.println("很遗憾，没有找到的啦！");
}
//二分法查找：(熟悉)
//前提：所要查找的数组必须有序。
//head是加的操作，end是减操作，最终会退出循环体的while(head<=end)
int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
int dest1 = -34;
dest1 = 35;
int head = 0;//初始的首索引
int end = arr2.length - 1;//初始的末索引
boolean isFlag1 = true;
while(head <= end){
int middle = (head + end)/2;
if(dest1 == arr2[middle]){
System.out.println("找到了指定的元素，位置为：" + middle);
isFlag1 = false;
break;
}else if(arr2[middle] > dest1){
end = middle - 1;
}else{//arr2[middle] < dest1
head = middle + 1;
}
}
if(isFlag1){
System.out.println("很遗憾，没有找到的啦！");
}
}
}
//冒泡
int[]arr1=new int[]{34,5,22,-98,6,-76,0,-3};
for (int i =0;i<arr1.length-1;i++){
for (int j=0;j<arr1.length-i-1;j++){
if (arr1[j]>arr1[j+1]){
int temp=arr1[j];
arr1[j]=arr1[j+1];
arr1[j+1]=temp;
}
}
}
System.out.println(Arrays.toString(arr1));
//反转
for(int i=0,j=arr1.length-1;i<arr1.length/2;i++,j--){
int temp=arr1[i];
arr1[i]=arr1[j];
arr1[j]=temp;
}
System.out.print(Arrays.toString(arr1));
5.冒泡
/*
* 数组的冒泡排序的实现
*
*/
public class BubbleSortTest {
public static void main(String[] args) {
int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
//冒泡排序
for(int i = 0;i < arr.length - 1;i++){
for(int j = 0;j < arr.length - 1 - i;j++){
if(arr[j] > arr[j + 1]){
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + "\t");
}
}
}
6.快排序
/**
* 快速排序
* 通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，
* 则分别对这两部分继续进行排序，直到整个序列有序。
* @author shkstart
* 2018-12-17
*/
public class QuickSort {
private static void swap(int[] data, int i, int j) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
private static void subSort(int[] data, int start, int end) {
if (start < end) {
int base = data[start];
int low = start;
int high = end + 1;
while (true) {
while (low < end && data[++low] - base <= 0)
;
while (high > start && data[--high] - base >= 0)
;
if (low < high) {
swap(data, low, high);
} else {
break;
}
}
swap(data, start, high);
subSort(data, start, high - 1);//递归调用
subSort(data, high + 1, end);
}
}
public static void quickSort(int[] data){
subSort(data,0,data.length-1);
}
public static void main(String[] args) {
int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
quickSort(data);
System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
}
}
7.返回索引
8.列表除以首元素
9.print(char[])
已验证
293
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
