常见的java结构形式汇总
1.Hello,World!(基本形式)
//类框架
public class Test{
//程序入口,主方法 这里的args代表的是一个变量名,可变.
public static void main(String[] args){
//输出语句
System.out.println("Hello,World!");
}
}
2.常量的表达形式
final int NUM = 10;//常量前面要加final(最终的),变量名要全部大写,中间连接用_不用空格
3.利用Scanner接收用户键盘输入
//导入Scanner类,注意语句位置
import java.util.*;
public class Test{
public static void main(String[] args){
//创建Scanner对象,给用户开一个通过键盘录入程序的入口 input
//注意Scanner的S要大写
Scanner input = new Scanner(System.in);
System.out.println("请输入姓名:");
//使用input获得'字符串'这里输出的结果是上面你输入的字
//如果你输入的是其他形式,比如整数,那么形式就变成了
//int 变量名 = input.nextInt();注意后面extInt中的I要大写(驼峰命名)
//另外double是input.nextDouble || next默认是字符串类型,注意没有nextchar
String name = input.next();
}
}
4.类型转换
1.强制类型转换
//如果表达式里有double类型,那么强制转换就转换为double类型.
int number1 = 1;
double number2 = 2.3;
float number3 = 4.5f;
//这里注意,因为里面有double类型数据,默认必须是double,其他如果想加的话可以是这种形式
//int number4 = (int)(number1+number2+number3) 注意等号后面的括号
//注意,在没有double类型的表达式中,就不一定非得用double了,但是int大部分情况下都要写成上面的形式.
double number4 = number1+number2+number3;
2.自动类型转换
/** char 规则1:不能对boolean类型转换
* | 规则2:转换双方分类要相同(比如都是数值类型)
* \/ 规则3:转换过程可能会有溢出或者精度丢失
*byte-->short-->int-->long 规则4:大转小必须要用到强制转换.
* || 规则5浮点到整数不是四舍五入,是砍掉小数
* float-->double *规则6:小的类型转换成大的类型
*/ //各种数据类型之间的大小关系图
double one = 3.14;
double two:
int three=1;
two = one+three;
System.out.println(two); //这里在输出时int自动转换成double
//--<报错>--three = three + two 这里由于three是int类型,比double小,所以three不能在前面
5.运算符
1.复杂的赋值运算符
/** += 1+=3 ----- 1=1+3
-= 1-=3 ----- 1=1-3
*= 1*=3 ----- 1=1*3
/= 1/=3 ----- 1=1/3
%= */
2.算术运算符
i++与++i的区别
//i++是先进行运算，运算结束之后i的值再加1。而++i是先先将i的值加1之后，才进行运算
int i = 1;
i=i++; //与 i=++i; 现在的输出结果是不一样的
//由于i++是先输出再运算,那么在这个代码中输出结果是2,++i的结果则是3
//++i是左值，直接原地操作，效率高点，但现在谁还在乎这一点效率呢
//如果++i,或者i++给输出之后下一次再输出的时候两个的值就一样的了.
//------------------------------------------------------------------------------
//注意运算符中System.out.println(6/4);注意输出数据类型是int类型 得出的数据是1
//除法运算中,前面的数比后面的数小,那么得出的结果就是0,取余时前面的比后面的小,那么得出的结果就是前面的数.
3.关系运算符
/**--------短路-------
&&(或)和||(与)会短路,而&跟|不会
*/ //例如:
int a = 7;
int b = 6;
System.out.println(++a<9||++b<9);
System.out.println(a);
System.out.println(b);
//这里由于短路,a=8,b还是=6,因为前面的对了,后面的就不用算了结果是true.
4.利用赋值运算符实现两个数据的交换,代码如下
int num1 = 1;
int num2 = 2;
int num3 = num1;//中间借助一下这个赋值进行交换.
num1 = num2;
num2 = num3;
System.out.println("此时num1与num2已经进行了交换"+num1+num2);
5.运算符的综合应用(测试题,输入卡号,找出卡号的各位)
public static void main(String[] args) {
//输入一个四位会员卡号，控制台计算会员卡号的各位数，并计算数之和。
//Scanner 用法先开一个口子
Scanner input = new Scanner(System.in);
//输出语句请输入一个四位会员卡号
System.out.println("请输入一个四位会员卡号：");
//输入的卡号是整数用int 与nextInt input获得输入的卡号并且输出
int no =input.nextInt();
//输出卡号
System.out.println("会员卡号是："+no);
//8369 取出个十百千的数值
int num1=no%10;//结果是9
int num2=no/10%10;//结果是6
int num3=no/100%10;//结果是3
int num4=no/1000;//结果是8
int num5=num1+num2+num3+num4;//结果是26
//用余10的方法拿到个位
System.out.println("卡号的个位数："+num1);
//用先除10再对商取余拿到十位
System.out.println("卡号的十位数："+num2);
//用先除100再对商取余拿到百位
System.out.println("卡号的百位数"+num3);
//用除1000的方法拿到千位
System.out.println("卡号的千位数"+num4);
System.out.println("会员卡号个位数："+num1+"十位数:"+num2+"百位数:"+num3+"千位数:"+num4);
System.out.println("卡号四位总数："+num5);
}
}
#### 6.条件判断表达式(三目运算符)
//例如判断一个数是否是偶数?
import java.util.*;
public class panduan{
public static void main(String[] args){
//Scanner数据引导输入
Scanner input = new Scanner(System.in);
System.out.print("请输入一个非0的数字:");
int number = input.nextInt();
//形式:条件?表达式1:表达式2---如果正确就输出表达式1,错误就输出表达式2
String result = (num%2==0)?"奇数":"偶数";
System.out.println(num+"是"+result);
}
}
6.if选择结构
1.if选择结构基本形式
/**基本形式: if(条件){ 条件里面的结果必须是布尔值,正确或错误.
//代码块 注意这里的空格.
}
下面是一个利用if选择结构来判断分数的一段代码*/
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入分数:");
int fen = input.nextInt();
if(fen>=90) { //基本if选择结构
System.out.println("考得不错获得奖励");
}
if(fen<90) {
System.out.println("考得不行没有奖励");
}
}
2.if…else选择结构
/**基本形式: if(条件){
//代码块1
}else{
//代码块2
} 就是不符合条件就输出代码块2
*/ //上面的也可以改成
if (fen>=90) {
System.out.println("考的不错获得奖励") //if...else选择结构
}else{
System.out.println("考的不行没有奖励")
}
// 利用if...else解决输入内容有误的问题
//.length()规定输入的长度,.hasNextInt()解决输入的是否是整数<---------重点
if(num.length()==4)/**规定num输入的长度,此时的输入情况在if上面
为:String 变量名 = input.next(); 注意length必须要用String形式*/
if(num>=1000&&num<=9999)//这里没有规定,可以是int形式-----解决是001,000等以0开头的情况
//判断输入的是否是int类型的数字
System.out.println("请输入数字：");
if(input.hasNextInt()==true){//这里注意.前面的是input.
int count=input.nextInt();//这里注意只能写在if{}里面
}
//以上写法，防止控制台出现一大坨红色的报错。
3.多重if选择结构
/**基本形式: if(条件1){ 在多个if很麻烦的情况下使用
//代码块1 如果条件1为真，执行这里；（条件为真才执行）
}else if(条件2){ else if--否则如果
//代码块2 否则，当条件2为真执行这里。（当条件1不为真，条件2为真执行这里）
}else{
//代码块3 条件1，条件2都不为真，执行这里
}
*/ //上面的再加一个条件60分以上考的还行,就变成了下面这样
if (fen>=90) {
System.out.println("考的不错获得奖励")
}else if(fen>=60){
System.out.println("考的还行") //多重if选择结构
}else{
System.out.println("考的不行没有奖励")//在写多重if时要遵循"从大到小"顺序
}
4.利用三目运算符或者if选择排序判断三个整数大小
import java.util.Scanner;
public class Test {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个整数：");
int x = sc.nextInt();
System.out.println("请输入第二个整数：");
int y = sc.nextInt();
System.out.println("请输入第三个整数：");
int z = sc.nextInt();
}
/**
* 第一种解法:利用if选择结构
*/
//判断两个数,将最小的数往后排,如果不符合条件
//数据不变,进入下一个循环.
//两两相较,将小的数排到后面.
if(x>y) {//判断
int temp =x;//调换位置
x = y;
y = temp;
}
if(x>z) {
int w =x;
zhengShu1 = z;
zhengShu3 = w;
}
if(y>z) {
int q =y;
y = z;
y = q;
}
System.out.println(zhengShu1);
System.out.println(zhengShu2);
System.out.println(zhengShu3);
/**
* 第二种解法:利用三目运算符
*/
//声明三个变量 分别是 最小值 中间值 最大值
int min,mid,max;
System.out.println(" 录入的数字是：" + x + "," + y + "," + z);
//确定最小值跟最大值
min = x >= y ? (y >= z ? z : y):(x >= z ? z : x);
max = x >= y ? (x >= z ? x : z) :(y >= z ? y : z);
//确定中间数
// mid = x < max && x > min ? x : (y < max && y > min ? y : z);//1 1 3 出错，1 3 3
// mid = (x == min || x == max) ? (y == min || y == max ? z :y) : x; //错误的判断方法
mid= x > y ? ( y > z ? y : ( x > z ? z : x )) : ( y < z ? y : (x > z ? x : z)); //方法一
// mid = (x + y + z) - (min + max); //方法二
System.out.println(" 排序的数字是：" + min + "," + mid + "," + max);
5.嵌套if选择结构(通过内外层语句的协作,增强程序的灵活性)
/**基本形式: 外 if （外层表达式）{ 1.一个选择结构中,可以嵌套另一个选择结构.
内 if （内层表达式）{ 2.嵌套格式正确的情况下，支持任意组合。
//内层代码块1
}else{ 执行过程:当外层条件满足时再执行内层.
//内层代码块2
层 }
层 }else{
//外层代码块
}
题目:学校举行运动会，百米赛跑跑入10秒内的学生有资格进决赛，根据性别分别进入男子组和女子组*/
public static void main(String[] args) {
// 跑进10秒进学赛。进了决赛根据性别进行分组
Scanner input = new Scanner(System.in);
System.out.println("请输入跑步成绩");
double time =input.nextDouble();
System.out.println("请输入性别");
String sex =input.next();
if(time<=10) { //--数值用==,>=,<=,输出要么true要么false
if(sex.equals("男")) { //--这里注意字符串之间的比较用.equals
System.out.println("进入男子决赛");
}else{
System.out.println("进入女子决赛");
}
}else {
System.out.println("未进入决赛");
}
}
6.switch选择结构
//这里是比多重if选择结构更为便捷的switch选择结构 特点是:条件为等值判断
//break是指跳出switch语句，执行switch后面的语句。每条case语句后面都应该跟break语句，否则的话它会继续执行后面case中的代码直到碰到break语句或switch结束.
/**基本形式: switch (表达式)
{
case 目标值1：
语句1；
break； //break表示符合目标跳出循环
case 目标值2： //case后面只能是常量,比如说在前面定义一个常量ABS,那么后面case ABS也可以
语句2；
break；
......
case 目标值n：
语句n；
break；
default：
语句n+1；
break；
}
注意:switch的表达式类型值可以为byte、short、int、char、enum(枚举)和String类型。
*/
//例题:请根据输入的条件判断所属道家宗派
import java.util.*;
public class dao1{}
public static void main(String[] args){
//这里有快速导包的快捷键:ctrl+shift+o
Scanner input = new Scanner(System.in);
System.out.println("请输入你的种族")
String dao1 = input.next();
switch (dao1) { //switch的s要小写
case "人":
System.out.println("人宗"); //这里的case可以有无限多个
break; //注意以break结尾.
case "神":
System.out.println("天宗");
break;
case "鬼":
System.out.println("地宗");
break;
default:
System.out.println("俗家弟子");
}
System.out.println("您是"+dao1);
}
}
7.switch的穿透
//case后面不加break,如果有一个case通过,那么下面的都会一一通过（break：挡板）
//有一个通过,剩下的都不做判断.
System.out.println("test switch:");
char level='c'; //计算lecel的值,为"c"
switch(level){
case 'a': //与a比较,不相等,则其后语句不执行
System.out.println('a');
case 'b': //与b比较,不相等,则其后语句不执行
System.out.println('b');
case 'c': //与c比较相等,则执行其后所有的语句.其后case都不判断.
System.out.println('c');
case 'd':
System.out.println('d');
default:
System.out.println(“您的输入有误”);
}
/**输出结果: test switch:
c
d
end
*/
// 典型例题:输入小明考试成绩,根据成绩区间输出奖励的东西100:车 90--100:电脑 60--80:手机 else:没有
public static void main(String[] args){ //导包就不写了
Scanner xm = new Scanner(System.in)
int score = xm.nextInt();
switch(score/10){ //这里主要是除以10的这个方法.
case 10:
System.out.println("车")
break;
case 9:
System.out.println("电脑")
break;
case 6:
case:7
case 8:
System.out.println("手机")
break;
default:
System.out.println("啥也没有")
break;
}
}
7.循环结构
1.while循环
/** 基本形式: while(表达式) while循环适合先做判断再进入循环.
{
语句; //直到
}
*/ //if、else、for、while、do 后面的执行语句不论有多少行，就算只有一行也要加“{}”，养成良好的编程习惯尤为重要。
// 当初始情况不满足循环条件时,while循环一次都不会执行.
//简单例题(他是计算直到值i>=100时输出):
int i =1;
while(i<=100){
System.out.println("第"+i+"遍");
i++;
}
//复杂例题(输出学生学习任务)
public static void main(String[] args) {
String answer;//表示是否合格
//Scanner 输入n或者y来判断下面的表达式
Scanner input = new Scanner(System.in);
System.out.println("合格了吗");
answer = input.next();
while("n".equals(answer))
//或者是while(!"y".equals(answer))
//意为answer只要不是y就输出
{
//执行学习任务
System.out.println("上午学习");
System.out.println("下午学习");
//每次执行完学习，需要验证一下，确保其能跳出循环**重点
System.out.println("完成了吗");
//如果是完成y跳出循环
answer = input.next();
}
//输出跳出循环结束
System.out.println("完成学习");
}
}
2.do…while循环
/** 基本形式: do{ do...while: 先循环再判断
//代码语句
}while(布尔表达式);
*/ // do...while循环不管任何情况都至少执行一次.
// 例题:老师让小明先编写程序,然后再让他编写程序,合格的话就不用写
//如果不合格就继续编写.
import java.util.*;
public class Test {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
String answer;
do{
System.out.print("上机编写程序");
System.out.print("是否合格?(y/n)");
answer = input.next();
}while(!"y".equals(answer));
//!"y"=="n"用这两个都可以
System.out.println("恭喜合格");
}
}
3.for循环(循环次数固定下,for比while简洁)
//为什么会比while简洁说明:
//while循环写输出一百次好好学习
int=0;
while(1<100){
System.out.println("好好学习");
}
//for循环输出一百次好好学习
for(int=0;i<100;i++){
System.out.println("好好学习");
}
/** for循环基础语法: for(参数初始化;条件判断;更新循环变量方法){
* //循环操作;
* }
*///顺序:初始化参数--判断条件,满足结束执行--不满足进行循环操作--更新循环变量--
// 例题:利用for循环输入某同学结业考试的5门课成绩,并计算平均分.
import java.util.*;
public class Test ;
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.println("输入学生姓名:");
name = input.next();
int sum = 0;//这个定义必须写在循环外面,因为循环外也要用到.
/** System.out.println("请输入5门课中第1门课的成绩:");
int report = input.nextInt();
System.out.println("请输入5门课中第2门课的成绩:");
int report = input.nextInt();
System.out.println("请输入5门课中第3门课的成绩:");
int report = input.nextInt();
System.out.println("请输入5门课中第4门课的成绩:");
int report = input.nextInt();
System.out.println("请输入5门课中第5门课的成绩:");
int report = input.nextInt(); 这是第一种基础写法*/
for(int i=1;i<=5;i++){
System.out.println("请输入五门课中第"+i+"门课的成绩:");
int report = input.nextInt();//这个可以不用在循环外定义,循环获得输入值.
sum += report;//每门课的成绩都要累加在sum值中,用+=符或者直接sum=sum+report
}
double avg = sum/5;//利用循环外的定义,求平均数
System.out.println(name+"的平均成绩"+avg);
}
}
// 例题2:打印加法表
public class Test {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入一个值:");
int num = input.nextInt();
int num1;
int num2;
System.out.println("根据这个值可以输出以下加法表:");
//num的判断条件之间用||(),&&()来连接,其他的用,连接 这个题只能写在一个for循环里
for (num1 = 0, num2 = num; num1 <= num||num2>=0; num1++, num2--) {
System.out.println(num1 + " + " + num2 + " = " + (num1 + num2));
}
}
// 例题3:计算100以内偶数和
public class Test03 {
public static void main(String[] args) {
int num;
int sum=0;//这里必须另外声明一个变量!!!!!!!!!!!!!!!!! 艹
// for (num = 1; num <= 100; num++) {
// if (num % 2 == 0) { //for循环可以套if选择结构,这里判断是否是偶数
// sum += num;
// }
// }
for(num=2;num % 2 == 0&&num<=100;num+=2) {
sum+=num; //这样一样可以
}
System.out.println(sum);
}
}
4.巩固习题
//1.用户录入一个整数,是1就输出,否则自减,并输出自减后的结果.
import java.util.*;
public class test{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
int zheng = input.nextInt();
if(zheng==1){ //首先如果输入的是1，则直接输出，注意等于是==
System.out.println(zheng);
}else{ //如果不是1的话走else，输出自减后的结果
zheng--;
System.out.println(zheng);
}
}
}
//从控制台输入一个数n,使用for循环实现求n!(n的阶乘)
//n!=n*(n-2)*(n-1)*...*n
//实现N!求和
import java.util.*;
public class test{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
int num = input.nextInt();
int x;
int y = 1;//这里必须赋值条件为1,0不行,因为0乘以任何数都为0
int z = 0;
for(x=1;x<=num;x++){//1:1*1/ 2:2*1*1/ 3:3*2*1*1/ 4:4*3*2*1*1规律:后乘以前
//y=num*(num-x)*1;
y *= n;//n!
z += y;//n!求和
y += y;
}
System.out.println(y);//阶乘
System.out.println(z);//各阶乘的和
// ----补充知识----
//-------随机数(random)
/**方式一：基础班
Math.random() 结果是[0.0 , 1) 基本形式
案例1，获取0~9：
(int)(Math.random()*10) *10=0--9的写法
案例2，获取10~19：
(int)(Math.random()*10)+10; *10)+10=10--19的写法*/
/** 方式二：高级班
导包：import java.util.Random;
Random ran=new Random();
ran.nextInt(3); //取值：0、1、2
*/
//-------绝对值(adsolate,简写abs)
//基本形式 int 输出绝对值定义的变量 = Math.abs(输入值1-输入值2);
5.多重循环
/** 基本形式(循环套循环--套中套)
for(条件){
for(条件){ 基本意思就是外层循环循环一次,内层循环循环"完成"一次
代码块 也就是说里面的条件都用上执行了一遍.
}
}
*/
//理解题 打印一个5行6列的长方形输出
public static void main(String[] args){
for(int a=1;a<=5;a++){ //行
for(int b=1;b<=6;b++){ //列
System.out.print("*"); //内容
}
System.out.println();
}
}
//打印一个平行四边形
1 public static void main(String[] args){
2 for(int a=1;a<=5;a++){
3 for(int b=1;b<=5-a;b++){
4 System.out.print(" ");
5 }
6 for(int b=1;b<=5;b++){
7 System.out.print("*")
8 }
9 System.out.println();
10 }
11 }
//打印一个三角形:与上面的1--5行代码相同部分不写了
for(int b=1;b<=2*a-1;b++){
System.out.print("*")
}Syso...
//打印输出99乘法表
public class Test0399chengfabiao {
public static void main(String[] args) {
int i = 1;
int a =1;
for(i=1;i<=9;i++) {
for(a=1;a<=i;a++) {
System.out.print(a+"*"+i+"="+(a*i)+" ");
}
System.out.println();
}
//break:输入某学生某五科成绩,输入负数时提示输入错误,并且计算平均分
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入你的姓名");
String name = input.next();
// 做一个标识，检查用户输入时，输入是否有误 true代表无误 变为false则为输入有误
boolean flag = true;
double sum = 0;
for (int i = 1; i <= 5; i++) {
System.out.println("请输入第" + i + "门功课的成绩：");
double fen = input.nextDouble();
if (fen < 0) { // 如果录入为负，停止录入并提示
System.out.println("输入的数值不符合规定。");
flag = false;// 不符合规定时，将标识变为false,因为这里是赋值,所以不用"=="
break;// break跳出循环之后会继续输出循环外的语句
}
sum += fen;//总成绩
}
//在循环外写一个选择结构，在输入正确的情况下输出平均值.
if (flag == true) {
double avg = sum / 5;
System.out.println(name + "平均成绩为" + avg);
}
}
/** eclipse快捷键
ctrl+D:删除当前行------alt+上键/下键:整理代码的位置
ctrl+M:放大,缩小-------ctrl+alt+下键:快速复制粘贴当前行
chrl+W:关闭当前窗口-------Ctrl+shift+F:整理代码
万能的代码提示:alt+/
单行注释:ctrl+/----------多行注释:ctrl+shift+/
//------------------------------调试-------------------------------------------------
------1:断点设置:在左边拉栏左键双击,会出来个点
------2:点击:debug
------3:F6:下一步...观察结果
------4:完成后吧红灯毙掉然后取消断点,然后再回到java窗口.
// 循环录入Java课的学生成绩,并统计分数大于等于80分的学生比例.
import java.util.*;
public static void main(String[] args){
Scanner input = new Scanner(System.in)
}
--------------break(挡板):强行终止循环并跳出
--------------continue(筛子):筛选正确的继续返回循环,错误的通过并执行下一步.
8.数组
1.修改数据
//修改数组内某一个数据内容:第二种情况
//第一种情况直接下标替换arr[数组下标]="xx"
import java.util.Arrays;
public class Test01 {
public static void main(String[] args) {
// 情况二:将"张三"改为"李四".
// 声明数组
String[] arr = { "张三", "李四", "王五", "陈六" };
// 1.判断张三是否在数组里面.存在就修改,不存在就给提示.
// 2.声明第三方变量
boolean bo = false;// false就是不存在,true就是存在.
System.out.println("修改前:" + Arrays.toString(arr));
//-------------------以下包含判断
for (int i = 0; i < arr.length; i++) {
if (arr[i].equals("张三")) {
bo = true;// 存在
arr[i] = "李四";//3.如果存在就进行修改
}
}
if (bo) {//这时的bo已经是true了
System.out.println("此人存在");//提示
System.out.println("修改后:" + Arrays.toString(arr));
} else {
System.out.println("此人不存在");
}
2.插入数据
//成绩插入并且跟着之前的数组进行排序
import java.util.Arrays;
import java.util.Scanner;
public class Test02 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);// Scanner输入
// 添加：在指定的位置插入
int[] arr = new int[6];// 设置数组长度是6,因为要多输入一个数,所以数组内只有5个有值的数.
// 给数组赋值
arr[0] = 99;
arr[1] = 85;
arr[2] = 82;
arr[3] = 63;
arr[4] = 60;
// 请求输入要插入的成绩
System.out.println("请输入需要插入的成绩:");
int num = input.nextInt();// 要插入的成绩
System.out.println("原数组：" + Arrays.toString(arr));
// 以下是求下标
// 初始化index的值,如果直接在循环里面写的话会循环打印.
int index = arr.length - 1;// 声明第三方的变量，接收值，这里不能瞎写！！！(代表如果不符合条件就是数组最后一位.)
for (int i = 0; i < arr.length; i++) {//for循环遍历输出数组arr的值.
if (num > arr[i]) {//给条件如果插入的成绩大于数组内某一个数据的值,那么这个插入的数据下标就变成这个对比数.
index = i;//给插入下标赋值
break;// 停止此循环
}
}
System.out.println("下标是：" + index);//输出下标
System.out.println("-----------------------------------------------以下是求插入后的数组");
// arr[5] = arr[4]; -------第一种错位方法,但只针对某一个大于下标1的数.局限性很大.
// arr[4] = arr[3];
// arr[3] = arr[2];
// arr[2] = arr[1];
// 编写循环进行错位
for (int j = arr.length - 1; j > index; j--) {
arr[j] = arr[j - 1];
}
System.out.println("新数组：" + Arrays.toString(arr));
arr[index] = num;// 把值覆盖(插入)
System.out.println("终极数组：" + Arrays.toString(arr));
}
//例题2:插入一个char类型的
public static void main(String[] args) {
char[] arr = new char[9];
// 赋值时添加8个，留1个！
arr[0] = 'a';
arr[1] = 'b';
arr[2] = 'c';
arr[3] = 'e';
arr[4] = 'f';
arr[5] = 'p';
arr[6] = 'u';
arr[7] = 'z';
System.out.println("原数组：" + Arrays.toString(arr));
char xxx = 'm';// 未知数
System.out.println("待插入的字符是：" + xxx);
int index = arr.length - 1;// 定义下标，第三方变量，记录
// 此循环的作用：记录下标
for (int i = 0; i < arr.length; i++) {
if (xxx < arr[i]) {
index = i;
break;// 停止此循环
}
}
System.out.println("插入字符的下标是：" + index);
// arr[8]=arr[7];
// System.out.println("第一轮：" + Arrays.toString(arr));
// arr[7]=arr[6];
// System.out.println("第二轮：" + Arrays.toString(arr));
// arr[6]=arr[5];
// System.out.println("第三轮：" + Arrays.toString(arr));
// 使用循环错位，把程序写成活的
for (int j = arr.length - 1; j > index; j--) {
arr[j] = arr[j - 1];
}
arr[index] = xxx;// 赋值
System.out.println("新数组：" + Arrays.toString(arr));
3.二分查找法
/*二分查找法:
基本思想:将一个数组中间的数取出来跟需要查找的数进行对比
中间数大于查找数那么就将中间数左边的一半再次寻找中间数对比,小于的话大意跟前面一样.*/
import java.util.Scanner;
public class Test03 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
// 数组的长度是7
int[] arr = { 6, 12, 14, 16, 23, 33, 58, 99 };
// 声明三个变量
int start = 0;// 开始下标
int end = arr.length - 1;// 结束下标
int center = -1;// 中间下标(任意赋值.中间下标取任意负数,只要不在数组下标范围之内即可)
System.out.println("请输入要查找的数");
int number = input.nextInt();
// 循环条件
while (start <= end) { //当开始下标大于小于结束下标时中间下标=(开始+结束)/2
center = (start + end) / 2;
if (arr[center] == number) {//如果中间数组下标内容等于输入的数字,那么就找到了下标就是这个中间数下标
System.out.println("恭喜你，找到了！下标是：" + center);
return;// 停止当前程序----注意这里的return不能用break,不然在正确输出时也会同时输出下面的"抱歉，没找到此数字！"
} else if (number > arr[center]) {//没有找到分两种情况,大于或小于,数字大于时.
start = center + 1;//开始下标变成中心下标+1,结束下标不变,然后后面的数据再进行二分查找.
} else {//数字小于时.
end = center - 1;//结束下标变成中心下标+1,开始下标不变,然后后面的数据再进行二分查找.
}
}
System.out.println("抱歉，没找到此数字！");
}
}
4.删除数组内某一重复的数据
/*题目一:现在有如下一个数组： int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5}; 要求将以上数组中
的0项去掉，将不为0的值存入一个新的数组，生成新的数组为
int newArr[]={1,3,4,5,6,6,5,4,7,6,7,5};*/
import java.util.Arrays;
public class test12 {
public static void main(String[] args) {
int oldArr[] = { 1, 3, 4, 5, 0, 0, 6, 6, 0, 5, 4, 7, 6, 7, 0, 5 };
// 定义一个第三方变量,记录不为0的数据个数.
int count = 0;
for (int abc : oldArr) {// 增强for循环遍历数组.
if (abc != 0) {
count++;// 如果oldArr里有不为0的数字那么就记录+1.
}
}
System.out.println("不为零的数据有" + count+"个");
// 声明新的数组,长度为count
int newArr[] = new int[count];
int num = 0;// 定义一个第三方变量,只记录不为0的个数.
// 给新的数组赋值
for (int i = 0; i < oldArr.length; i++) {
if (oldArr[i] != 0) {// 过滤出不是0的数字
newArr[num] = oldArr[i];
num++;
}
}
System.out.println("新数组:" + Arrays.toString(newArr));
}
5.基础回顾
import java.util.*;
Scanner input = new Scanner(System.in)
int arr[] = new int[3];
for (int i = 0; i < arr.length; i++) {//常见的控制台输入给数组赋值方法
arr[i] = input.nextint();
}
6.排序方法
//1.升序
//1.直接调用sort方法
Arrays.sort(数组名);
//2.冒泡排序(下面的降序也可以用这个)
//外层循环:n-1(n代表的是数组长度)
for (int i=0 ; i < arr.length-1;i++){
//内层循环:n-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;//搞定!
//2.降序
//1.上面的冒泡排序
//2.先升序后降序(这里利用sort方法进行升序)
Arrays.sort(数组名);
for ( int i=arr.length-1;i >=0 ;i--){
System.out.println(arr[i]);
}
for ( int i=0;i<arr.length/2;i++){
int temp = arr[i];
arr[i] = arr [arr.length-1-i];
arr[arr.length-1-i] = temp;
System.out.println(arr[i]);
}
7.二维数组
//写法1
int[][] arr = { { 12, 18, 19 }, { 30 } };
//写法2
// 录入3个班级中，两位同学的姓名
// 声明二维数组
String[][] arr = new String[3][3];
// 赋值
// 第一个班级
arr[0][0] = "张三";
arr[0][1] = "李四";
// null
// 第二个班级
arr[1][0] = "红红";
arr[1][1] = "蓝蓝";
// null
// 第三个班级
arr[2][0] = "熊大";
arr[2][1] = "熊二";
arr[2][2] = "光头强";
System.out.println(Arrays.toString(arr[0]));
System.out.println(Arrays.toString(arr[1]));
System.out.println(Arrays.toString(arr[2]));
//题目:使用二维数组来接收：三个班级，前2名同学的成绩
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
// ，定义数组int[][] arr=new int[3][2];
// ，使用二重循环向此二维数组录入成绩，最后再做输出打印。
// 3个班，每个班2人
int[][] arr = new int[3][2];
System.out.println("长度：" + arr.length);
// 外层循环控制的是班级数量
for (int i = 0; i < arr.length; i++) {//这里使用循环来给数组赋值
System.out.println("请输入【" + (i + 1) + "班】的成绩：");
// 内层循环控制每个班级的人数
for (int j = 0; j < arr[i].length; j++) {
System.out.print("请输入第" + (j + 1) + "位同学的成绩：");
arr[i][j] = input.nextInt();
}
System.out.println();
9.面向对象
1.类和对象
//1.定义类 类名首字母大写 大驼峰命名
public class School {
//2.定义属性 小驼峰
// < 数据类型 属性名 > 权限修饰符不写:默认public
String name; // 名
public String address;//地址
//3.定义方法
//权限修饰符 public:公共 代表谁都可以调用此方法
// void: 返回值类型为空 代表没有返回值
// show:方法名
// (): 参数列表
public void show(){
System.out.println("学校名称是"+name+"学校地址:"+address);
}
//标识符:boolean类型的定义:boolean flag = false;
}
//形式参数与实际参数
//形式参数:形参列表规定了: 数据类型 个数 顺序 在调用方法时必须与之相同
public String abc(String fruit,int num)括号里就是形式参数
//实际参数:在调用的里面写
String fruit = ac.abc("葡萄",2)这个括号里就是实际参数
//测试类调用
public class Test {
public static void main(String[] args) {
// 1.引用学校类
// 类名 对象名 = new 类名();
School center = new School();
// 2.使用属性<给属性赋值>
// 对象名.属性
center.name = "课工场产教融创基地";
center.address ="北京市大兴区中科电商谷9号楼";
// 3.调用方法
// 对象名.方法名
center.show();
//输出就不写了......
//方法传参时基本数据类型(值传递)跟引用数据类型(引用传递)的区别
//值传递: 传递的是值本身,在任何地方修改传递过去的数据对变量本身没有影响
//引用传递: 传递的是地址值 在传递过后修改数据 原本的数据也会发生变化
//例题1:模拟实现用户密码管理:输入旧的用户名和密码,
//如果正确,方有权限更新;从键盘获取新的密码,进行更新
import java.util.Scanner;
public class Test05 {
//新建密码类
//属性
String name;
String password;
//方法
public void show() {
System.out.println("管理员用户名为："+name+"；密码为："+password);
}
//调用与输出
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String name;
String password;
//调用Test05类
Test05 admin = new Test05();
//给属性赋值
admin.name="admin";
admin.password = "123456";
//调用方法
admin.show();
System.out.print("请输入用户名：");
name =input.next();
System.out.print("请输入密码：");
password =input.next();
if(admin.name.equals(name) && admin.password.equals(password)) {
//输入用户名和密码正确，才有权限修改密码
System.out.print("\n请输入新密码");
admin.password =input.next();
System.out.println("修改密码成功，您的密码为"+admin.password);
}else {
//输入用户名和密码不正确，没有权限修改密码
System.out.println("用户名和密码不匹配！您没有权限更新管理员信息。");
/**例题2: --<学员信息管理系统>--
* 增加学员姓名
* 在保存了多个学生姓名的数组中,指定查找区间,
* 查找某个学生姓名并显示是否查找成功
*/
public class Test06 {
static Scanner input = new Scanner(System.in);
public static void main(String[] args) {
//Scanner input = new Scanner(System.in);
//String[] names = {"戴伟","曲泓宇","郭子航","徐豪","孙壮虎"};
String[] names = new String[5];
//调用Test06的方法
Test06 sm = new Test06();
sm.addStudent(names);// 调用添加姓名
sm.showNames(names);// 调用展示学员列表方法
// 查找学员
System.out.println("请输入要查找的学员姓名:");
String name = input.next();
System.out.println("请输入开始的查找位置:");
int startIndex = input.nextInt();
System.out.println("请输入结束的查找位置");
int endIndex = input.nextInt();
boolean result = sm.searchStudent(names,name,startIndex,endIndex);
if (result){
System.out.println("有此学生");
}else{
System.out.println("查无此人");
}
}
private boolean searchStudent(String[] names, String name, int startIndex, int endIndex) {
// 依次对比数组中是否有name相同的学生姓名
for (int i = startIndex-1; i < endIndex; i++) {
if (names[i].equals(name)){
return true;
}
}
return false;
}
// 遍历数组
public void showNames(String[] names){
for (String name : names) {
System.out.print(name+"\t");
}
}
// 编写带参方法 指定查找区间 查找的学员姓名 查找学员是否存在
public void addStudent(String [] names){
for (int i = 0; i < names.length; i++) {
System.out.print("请输入第"+(i+1)+"位学员的姓名:");
names[i] = input.next();
}
}
/*
权限修饰符: public:公共的 private:私有的 default:默认的 protected:受保护的
*/
//成员变量与局部变量
//类下面的变量称之为成员变量 方法中的变量称之为局部变量
public class Student {
public int score;
public String name;
// 在每次创建对象是 事实上的调用了类的无参 构造 每个类系统都会默认提供一个无参构造
public Student(){
score = 60;
name = "李云迪";
System.out.println("构造方法执行了");
}
// 有参构造 一旦你写了有参构造 系统就不再提供无参
/*public Student(String n,int s){ // 初始化对象的时候可以给对象赋值
name = n;
score = s;
}*/
// 方法名相同 参数列表不同(个数,数据类型,顺序) 与返回值类型,和权限修饰符无关
// 方法重载:自动的去根据你传递的参数执行对应的方法
public Student(String name,int score){ // 初始化对象的时候可以给对象赋值
/*this:这个 当前对象*/
this.name = name;
this.score = score;
}
/**
* 两个数相加
* @param num1
* @param num2
* @return
*/
public int add(int num1,int num2){
return num1 + num2;
}
public int add(int num1,int num2,int num3){
return num1+num2+num3;
}
}
//--------------------------------------------------------------------------------------------------------------
import java.util.*;
public class Test {
Scanner input = new Scanner(System.in);
public static void main(String[] args) {
// 对象数组 里面存储的是一个一个的学生对象
Student[] students = new Student[5];
/*int[] i = new int[5];
String[] str = new String[5];*/
/* Student student1 = new Student();
student1.score = 50;
student1.name = "zs";
// 将对象存储在学生数组中
students[0] = student1;*/
Test test = new Test();
test.addStudent(students);
test.updateStudent(students);
test.showStudent(students);
}
/**
* 展示 学生信息
* @param students
*/
public void showStudent(Student[] students){
for (int i = 0; i < students.length; i++) {
System.out.println("学生姓名:"+students[i].name+",学生分数:"+students[i].score);
}
}
/**
* 修改学生的成绩
* @param students
*/
public void updateStudent(Student[] students){
boolean flag = false;
// 判断是否有小与60分的人
for (int i = 0; i < students.length; i++) {
if (students[i].score < 60){
flag = true;
break;
}
}
// 集体提高
if (flag){
for (int i = 0; i < students.length; i++) {
students[i].score+=2;
}
}
}
/**
* 添加学员
* @param students
*/
public void addStudent(Student[] students){
// 创建5个学生对象 赋值 成绩存储起来 用什么存对象
for (int i = 0; i < students.length; i++) {
students[i] = new Student();// 每次循环创建一个对象存入数组中
// 为对象中的数据进行赋值
System.out.println("请输入第"+(i+1)+"位同学的姓名");
students[i].name = input.next();
System.out.println("请输入第"+(i+1)+"位同学的成绩");
students[i].score = input.nextInt();
}
}
}
//--------------------------------------------------------------------------------------------------------------
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
Student student = new Student("张三", 18);
student.score = 34;
student.name = "ss";
System.out.println(student.name + " " + student.score);
Scanner input = new Scanner(System.in);
int add = student.add(1, 4);
int add1 = student.add(2, 5, 7);
System.out.println(add+"\t"+add1);
}
}
//---------------------------------------------------------------------------------------------------------------
public class Test2 {
public static void main(String[] args) {
Student student = new Student();
System.out.println(student.name+""+student.score);
}
}
//例题1.理解题
/**
* @author 徐豪
* getter与settle理解
* return与this.
*/
public class Student {
private int age;
//setter:设置属性并且赋值
public void setAge(int age){
this.age = age;
}
//get:获取值
public int getAge(){
return age;
}
}
//-------------------------------------------------------------------------------------------------------
public class Test {
public static void main(String[] args) {
Student student = new Student();
//将值赋值给public void setAge(int age)中的int age
//然后通过this.age = age;把刚刚赋值到age的值重新赋值给上面的private int age
student.setAge(56);
//get属性就是得到 public int getAge(){ 中 return age 的值,返回的值
//就是上面重复赋给age的值 return age;
//所以说get跟set真的很重要 }
System.out.println(student.getAge());
}
}
//例题2:理解题
/**
* @author 徐豪
* 实现简易计算器,分别实现两个整数.三个浮点数的加法运算
*/
public class Calculator {
public static int add(int num1, int num2) {
return num1 + num2;
}
public static double add(double num1, double num2, double num3) {
return num1 + num2 + num3;
}
}
//----------------------------------------------------------------------------------------------------------
public class Test01 {
public static void main(String[] args) {
Calculator cal = new Calculator();
int add = Calculator.add(6,4);
double add2 = Calculator.add(9.45,43.6,434.5);
System.out.println(add+"\n"+add2);
}
}
//例题3
import java.util.Scanner;
/**
* @author 徐豪
* 狗狗类--封装
* 可供访问跟操作的方法: *(getter settle)区别
*/
public class Animal {
private String name;
private String style;
private String sex;
private int health;
private int love;
//快捷键:alt + insert生成
//封装--get
public String getName() {
return name;
}
//设置名字
public void setName(String name) {
this.name = name;
}
public String getStyle() {
return style;
}
public void setStyle(int style) {
if (style == 1) {
this.style = "狗狗";
} else if (style == 2) {
this.style = "企鹅";
}
}
public String getSex() {
return sex;
}
public void setSex(int sex) {
if (sex == 1) {
this.sex = "Q仔";
} else if (sex == 2) {
this.sex = "Q妹";
}
}
public int getHealth() {
return health;
}
public void setHealth(int health) {
if (health > 100 || health < 0) {
System.out.println("健康值应该在0-100之间,默认值是60");
this.health = 60;
} else {
this.health = health;
}
}
public int getLove() {
return love;
}
public void setLove(int love) {
if (love > 100 || love < 0) {
System.out.println("亲密度应该在0-100之间,默认值是60");
this.love = 60;
return;
} else {
this.love = love;
}
}
public void downSay() {
System.out.println("宠物的自白:");
System.out.println("我的名字叫" + name + ",健康值是" + health + ",和主人的亲密度是" + love + ",我的性别是" + sex);
}
// this.name是变量初始化
}
//---------------------------------------------------------------------------------------------------------------
import java.util.Scanner;
/**
* @author 徐豪
* 使用封装实现电子宠物系统的切类正确输入健康值和亲密度.
* 保证健康值的有效性(1-100),否则取60
* 保证亲密度的有效性(1-100),否则取60
*/
public class PetShop{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
Animal pet = new Animal();
System.out.println("欢迎您来到宠物店!");
System.out.print("请输入要领养的宠物的名字: ");
pet.setName(input.next());
System.out.print("请选择要领养的宠物类型:(1.狗狗 2.企鹅) ");
pet.setStyle(input.nextInt());
System.out.print("请选择"+pet.getStyle()+"的性别: (1.Q仔 2.Q妹)");
pet.setSex(input.nextInt()) ;
System.out.println("请输入"+pet.getStyle()+"的健康值:(1~100之间):");
pet.setHealth(input.nextInt());
System.out.println("请输入"+pet.getStyle()+"的亲密度:(1~100之间):");
pet.setLove(input.nextInt());
pet.downSay();
// System.out.println("宠物的自白:");
// System.out.println("我的名字叫"+ pet.getName()+",健康值是"+pet.getHealth()+",和主人的亲密度是"+pet.getLove()+",我的性别是"+pet.getSex());
}
}
1496
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
