持续更新中…
1.字符串练习：
public class ChangeCharTest{
public static void main(String[] args){
System.out.println("书名\t作者\t价格\t销量");
System.out.println("三国\t罗贯中\t120\t1000");
/*\\ 优化*/
System.out.println("书名\t作者\t价格\t销量\n三国\t罗贯中\t120\t1000");
}
}
总结：
- 在编程时注意单词的拼写正确
- 注意是英文下的符号
- 慢慢积累学会看报错信息
2.文档注释（常用）
/**
* @author [liu]
* @version [1.0]
*/
public class DocTest{
public static void main(String[] args) {
System.out.println("hello");
}
}
D:\Java_code>javadoc -d D:\Java_code -author -version DocTest.java
3.输出如下格式，且只能使用一个System.out.println
public class ChangeCharTest{
public static void main(String[] args){
String name = "刘颜";
int age = 23;
float grade = 130.5;
char gender = '女';
String hobby = "网球、看书";
System.out.println("姓名\t年龄\t成绩\t性别\t爱好\n"+name+"\t"
+age+"\t"+grade+"\t"+gender+"\t"+hobby);
}
}
总结：
- 明确变量的类型和值
- 输出中如果需要按照原样输出，就使用双引号；如果需要输出变量的值，就不要使用双引号；转义字符需要在双引号中
4.运算符
public class ChangeCharTest{
public static void main(String[] args){
System.out.println(10/4); -->2
System.out.println(10.0/4); -->2.5
double a = 10/4;
System.out.println(a); -->2.0
}
}
总结：
- 整数相除得到int类型的数据
- 浮点数和整数相除，按照高精度来定类型，即得到浮点数
5.i++和++i。注意对于自身赋值，会出现一个临时变量去保存数值
i++:①先将i赋值给temp，此时temp=1；②自加，此时i=2;③最后把temp赋值给i，此时i=1
public class test{
public static void main(String[] args) {
int i = 1;
i = i++;
System.out.println(i);
}
}
++i①自加，此时i=2;②再将i赋值给temp，此时temp=2；③最后把temp赋值给i，此时i=2
public class test{
public static void main(String[] args) {
int i = 1;
i =++i;
System.out.println(i);
}
}
6.三元运算符
口诀：一真大师
注意：
① 此处是++用法作为表达式使用，且得到的值需要赋值给result，因此不需要临时变量temple
② 表达式1、2的数据类型<=result的数据类型，如果不满足，可以进行强制转换类型
public class test{
public static void main(String[] args) {
int a = 1;
int b = 2;
int result = a < b ? a ++ : - - b ;
// 条件成立，将a 先赋值给result，然后a自加
int result = a > b ? a ++ : - - b ;
// 条件不成立，先将b减1后赋值给result
}
}
7.键盘输入
import java.util.Scanner; // 1.导入java.util包下的Scanner类
public class Input {
public static void main(String []args) {
Scanner myScanner = new Scanner(System.in);
//2.使用new创建一个Scanner对象，myScanner就是Scanner类的对象
System.out.println("请输入名字：");//3.使用类下面的方法，接收用户的输入
String name = myScanner.next();
}
}
8.打印金字塔
总结：
外循环中的条件判断语句决定行数；
内循环的条件判断语句决定每行的个数
public class tt {
public static void main(String []args) {
//① 需求：
//打出一个空心金字塔
// *
// * *
// * *
// * *
//*********
//② 分析：
//化繁为简：
//1.首先打印出一个矩形：
//***** 每层有5个*
//*****
//*****
//*****
//*****
//2.首先打印出一个三角形：
//* 1
//** 2
//*** 3
//**** 4
//***** 5
//3.首先打印出一个金字塔：
// * 1 4=5-1
// *** 3 3=5-2
// ***** 5 2=5-3
// ******* 7 1=5-4
//********* 9 0=5-5
//4.首先打印出一个空心金字塔：
// * 除了最后一层全部输出，其他层数只输出一头一尾的*
// * *
// * *
// * *
//*********
//先死后活：
//行数定义一个变量
int num = 10;
for(int j = 1; j <= num ; j++){
for(int m = 1; m<=num-j ; m++){
System.out.print(" ");
}
for(int i = 1; i <= 2*j-1 ; i++){
if(i==1||i==2*j-1||j==num){
System.out.print("*");
}else{
System.out.print(" ");
}
}
System.out.print("\n");
}
}
}
9.乘法表
public class tt {
public static void main(String []args) {
for(int i = 1 ; i <= 9 ; i++){
for(int j = 1 ; j <= i ; j++){
System.out.print(j+"*"+i+"="+i*j+"\t");
}
System.out.print("\n");
}
}
}
10.循环
输出1-100内不能被5整除的数，且每行5个
总结：要求每行5个，那就用count计数器
public class breakDemo {
public static void main(String []args) {
int count = 0;
for(int j = 1;j<=100;j++){
if(j%5!=0){
System.out.print(j+"\t");
count++;
if(count%5==0){
System.out.print("\n");
continue;
}
}
}
}
}
11.输出a-z、z-a
总结:字符也可以放到循环里面比较大小
char的本质是一个整数，可以和整数进行加减，但是最终输出字母
public class breakDemo {
public static void main(String []args) {
for(char num = 'a';num<='z';num++){
System.out.print(num+" ");
}
System.out.print("\n");
for(char num2 = 'z';num2>='a';num2--){
System.out.print(num2+" ");
}
}
}
12.注意数学公式中的陷阱
1-1/2+1/3-1/4…1/100
此处要将数学公式中的1表示成1.0
public class breakDemo {
public static void main(String []args) {
double sum = 0;
for(int i =1;i<=100;i++){
if(i%2==0){
double num1 = -(1.0/i);
sum += num1;
}else{
double num2 = 1.0/i;
sum += num2;
}
}
System.out.print(sum);
}
}
13.逆序输出数组
public class breakDemo {
public static void main(String []args) {
//第一种思路：将数组的前后数值进行交换
//a={11,22,33,44,55,66}
//a[0]~a[5]
//a[1]~a[4]
//a[2]~a[3]
//i~length-i-1
int[] a = {11,22,33,44,55,66};
int[] c = {11,22,33,44,55,66};
for(int i=0;i<a.length/2;i++){
int temp = a[i];
a[i] = a[a.length-1-i];
a[a.length-1-i] = temp;
}
for(int i=0;i<a.length;i++){
System.out.print(a[i]);
}
//第二种思路：将原数组逆序赋值给新的数组
//a[0]~b[5]
//a[1]~b[4]
//a[2]~b[3]
//a[3]~b[2]
//a[4]~b[1]
//a[5]~b[0]
//一共需要赋值6次
System.out.print("###################");
int len = c.length;
int [] b = new int [len];
for(int i=0;i<len;i++){
b[len-i-1] = c[i];
}
for(int i = 0; i<len; i++){
System.out.print(b[i]);
}
}
}
14.给数组动态增加一个用户输入的数
import java.util.Scanner;
public class breakDemo {
public static void main(String []args) {
int [] a = {1,2,3};
do{
int [] b = new int[a.length+1];
Scanner myScanner = new Scanner(System.in);
System.out.print("请输入数据：");
int c = myScanner.nextInt();
for(int i=0;i<a.length;i++){
b[i] = a[i];
}
//将用户输入数据动态放入数组
b[a.length] = c;
//输出此时的新数组
a = b;//将b的地址赋值给a
//遍历输出a数组
for(int i=0;i<a.length;i++){
System.out.print(a[i]);
}
//询问用户是否继续输入
System.out.print("\n是否继续输入：y/n?\n");
char d = myScanner.next().charAt(0);
if(d=='n'){
break;
}
}while(true);
}
}
15.缩小数组
import java.util.Scanner;
public class breakDemo {
public static void main(String []args) {
int [] a = {1,2,3,4,5};
do{
int [] b = new int[a.length-1];
Scanner myScanner = new Scanner(System.in);
for(int i=0;i<a.length-1;i++){
b[i] = a[i];
}
a = b;
System.out.print("新的数组是：\n");
for(int i=0;i<a.length;i++){
System.out.print(a[i]+"\t");
}
//询问用户是否继续输入
System.out.print("\n是否继续缩小：y/n?\n");
char d = myScanner.next().charAt(0);
if(d=='n'){
break;
}
if(a.length==1){
System.out.print("不能继续缩小了\n");
break;
}
}while(true);
}
}
16.冒泡排序
public class breakDemo {
public static void main(String []args) {
int [] a = {24,69,80,57,13,100,555,666};
int temp = 0;
for(int j =1;j<a.length;j++){
for(int i=0;i<a.length-j;i++){
if(a[i]>a[i+1]){
temp = a[i+1];
a[i+1] = a[i];
a[i] = temp;
if(i==a.length-2){
break;
}
}
}
}
for(int i=0;i<a.length;i++){
System.out.print(a[i]+"\t");
}
}
}
老韩思路：
public class BubbleSort {
//编写一个main方法
public static void main(String[] args) {
//老韩 化繁为简，先死后活
//
//
/*
数组 [24,69,80,57,13]
第1轮排序: 目标把最大数放在最后
第1次比较[24,69,80,57,13]
第2次比较[24,69,80,57,13]
第3次比较[24,69,57,80,13]
第4次比较[24,69,57,13,80]
*/
int[] arr = {24, 69, 80, 57, 13, -1, 30, 200, -110};
int temp = 0; //用于辅助交换的变量
//将多轮排序使用外层循环包括起来即可
//先死后活 =》 4就是 arr.length - 1
for( int i = 0; i < arr.length - 1; i++) {//外层循环是4次
for( int j = 0; j < arr.length - 1 - i; j++) {//4次比较-3次-2次-1次
//如果前面的数>后面的数，就交换
if(arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
System.out.println("\n==第"+(i+1)+"轮==");
for(int j = 0; j < arr.length; j++) {
System.out.print(arr[j] + "\t");
}
}
// for( int j = 0; j < 4; j++) {//4次比较
// //如果前面的数>后面的数，就交换
// if(arr[j] > arr[j + 1]) {
// temp = arr[j];
// arr[j] = arr[j+1];
// arr[j+1] = temp;
// }
// }
// System.out.println("==第1轮==");
// for(int j = 0; j < arr.length; j++) {
// System.out.print(arr[j] + "\t");
// }
// /*
// 第2轮排序: 目标把第二大数放在倒数第二位置
// 第1次比较[24,69,57,13,80]
// 第2次比较[24,57,69,13,80]
// 第3次比较[24,57,13,69,80]
// */
// for( int j = 0; j < 3; j++) {//3次比较
// //如果前面的数>后面的数，就交换
// if(arr[j] > arr[j + 1]) {
// temp = arr[j];
// arr[j] = arr[j+1];
// arr[j+1] = temp;
// }
// }
// System.out.println("\n==第2轮==");
// for(int j = 0; j < arr.length; j++) {
// System.out.print(arr[j] + "\t");
// }
// 第3轮排序: 目标把第3大数放在倒数第3位置
// 第1次比较[24,57,13,69,80]
// 第2次比较[24,13,57,69,80]
// for( int j = 0; j < 2; j++) {//2次比较
// //如果前面的数>后面的数，就交换
// if(arr[j] > arr[j + 1]) {
// temp = arr[j];
// arr[j] = arr[j+1];
// arr[j+1] = temp;
// }
// }
// System.out.println("\n==第3轮==");
// for(int j = 0; j < arr.length; j++) {
// System.out.print(arr[j] + "\t");
// }
// /*
// 第4轮排序: 目标把第4大数放在倒数第4位置
// 第1次比较[13,24,57,69,80]
// */
// for( int j = 0; j < 1; j++) {//1次比较
// //如果前面的数>后面的数，就交换
// if(arr[j] > arr[j + 1]) {
// temp = arr[j];
// arr[j] = arr[j+1];
// arr[j+1] = temp;
// }
// }
// System.out.println("\n==第4轮==");
// for(int j = 0; j < arr.length; j++) {
// System.out.print(arr[j] + "\t");
// }
}
}
17.杨辉三角
public class YangHui {
//编写一个main方法
public static void main(String[] args) {
/*
使用二维数组打印一个 10 行杨辉三角
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
规律
1.第一行有 1 个元素, 第 n 行有 n 个元素
2. 每一行的第一个元素和最后一个元素都是 1
3. 从第三行开始, 对于非第一个元素和最后一个元素的元素的值. arr[i][j]
arr[i][j] = arr[i-1][j] + arr[i-1][j-1]; //必须找到这个规律
*/
int[][] yangHui = new int[12][];
for(int i = 0; i < yangHui.length; i++) {//遍历yangHui的每个元素
//给每个一维数组(行) 开空间
yangHui[i] = new int[i+1];
//给每个一维数组(行) 赋值
for(int j = 0; j < yangHui[i].length; j++){
//每一行的第一个元素和最后一个元素都是1
if(j == 0 || j == yangHui[i].length - 1) {
yangHui[i][j] = 1;
} else {//中间的元素
yangHui[i][j] = yangHui[i-1][j] + yangHui[i-1][j-1];
}
}
}
//输出杨辉三角
for(int i = 0; i < yangHui.length; i++) {
for(int j = 0; j < yangHui[i].length; j++) {//遍历输出该行
System.out.print(yangHui[i][j] + "\t");
}
System.out.println();//换行.
}
}
}
18.输入一个元素到升序数组后仍然满足升序
public class Homework04 {
//编写一个main方法
public static void main(String[] args) {
/*
已知有个升序的数组，要求插入一个元素，该数组顺序依然是升序, 比如:
[10， 12， 45， 90], 添加23 后, 数组为 [10， 12，23， 45， 90]
思路 本质数组扩容 + 定位
1. 我们先确定 添加数应该插入到哪个索引
2. 然后扩容
*/
//先定义原数组
int[] arr = {10, 12, 45, 90};
int insertNum = 111;
int index = -1; //index就是要插入的位置
//遍历 arr数组， 如果发现 insertNum<=arr[i], 说明 i 就是要插入的位置
//使用 index 保留 index = i;
//如果遍历完后，没有发现 insertNum<=arr[i]， 说明 index = arr.length
//即：添加到arr的最后
for(int i = 0; i < arr.length; i++) {
if(insertNum <= arr[i]) {
index = i;
break; //找到位置后，就退出
}
}
//判断index 的值
if(index == -1) { //说明没有还没有找到位置
index = arr.length;
}
//扩容
//先创建一个新的数组，大小 arr.length + 1
int[] arrNew = new int[arr.length + 1];
//下面老师准备将arr的元素拷贝到 arrNew ,并且要跳过 index位置
/*
分析:
int[] arr = {10, 12, 45, 90};
arrNew = { }
*/
//i 控制arrNew的下标 , j用来控制arr数组的下标
for(int i = 0, j = 0; i < arrNew.length; i++) {
if( i != index ) { //说明可以把 arr的元素拷贝到 arrNew
arrNew[i] = arr[j];
j++;
} else { //i这个位置就是要插入的数
arrNew[i] = insertNum;
}
}
//让arr 指向 arrNew , 原来的数组，就成为垃圾，被销毁
arr = arrNew;
System.out.println("======插入后，arr数组的元素情况======");
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
}
}
19.数组扩容
import java.util.Scanner;
public class ArrayAdd02 {
//编写一个main方法
public static void main(String[] args) {
/*
要求：实现动态的给数组添加元素效果，实现对数组扩容。ArrayAdd.java
1.原始数组使用静态分配 int[] arr = {1,2,3}
2.增加的元素4，直接放在数组的最后 arr = {1,2,3,4}
3.用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？y/n
思路分析
1. 定义初始数组 int[] arr = {1,2,3}//下标0-2
2. 定义一个新的数组 int[] arrNew = new int[arr.length+1];
3. 遍历 arr 数组，依次将arr的元素拷贝到 arrNew数组
4. 将 4 赋给 arrNew[arrNew.length - 1] = 4;把4赋给arrNew最后一个元素
5. 让 arr 指向 arrNew ; arr = arrNew; 那么 原来arr数组就被销毁
6. 创建一个 Scanner可以接受用户输入
7. 因为用户什么时候退出，不确定，老师使用 do-while + break来控制
*/
Scanner myScanner = new Scanner(System.in);
//初始化数组
int[] arr = {1,2,3};
do {
int[] arrNew = new int[arr.length + 1];
//遍历 arr 数组，依次将arr的元素拷贝到 arrNew数组
for(int i = 0; i < arr.length; i++) {
arrNew[i] = arr[i];
}
System.out.println("请输入你要添加的元素");
int addNum = myScanner.nextInt();
//把addNum赋给arrNew最后一个元素
arrNew[arrNew.length - 1] = addNum;
//让 arr 指向 arrNew,
arr = arrNew;
//输出arr 看看效果
System.out.println("====arr扩容后元素情况====");
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
//问用户是否继续
System.out.println("是否继续添加 y/n");
char key = myScanner.next().charAt(0);
if( key == 'n') { //如果输入n ,就结束
break;
}
}while(true);
System.out.println("你退出了添加...");
}
}
20.求10个1-100之间的随机数的均值，最大值，及判断是否生成8
public class Homework05 {
//编写一个main方法
public static void main(String[] args) {
/*
随机生成10个整数(1_100的范围)保存到数组，
并倒序打印以及求平均值、求最大值和最大值的下标、
并查找里面是否有 8 Homework05.java
*/
int[] arr = new int[10];
//(int)(Math.random() * 100) + 1 生产 随机数 1-100
for(int i = 0; i < arr.length; i++) {
arr[i] = (int)(Math.random() * 100) + 1;
}
System.out.println("====arr的元素情况=====");
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
System.out.println("\n====arr的元素情况(倒序)=====");
for(int i = arr.length -1; i >= 0; i--) {
System.out.print(arr[i] + "\t");
}
//平均值、求最大值和最大值的下标
//我们这里将需要一起完成
//
double sum = arr[0];
int max = arr[0];
int maxIndex = 0;
for(int i = 1; i < arr.length; i++ ) {
sum += arr[i]; //累积和
if( max < arr[i]) {//说明max不是最大值，就变化
max = arr[i];
maxIndex = i;
}
}
System.out.println("\nmax=" + max + " maxIndex=" + maxIndex);
System.out.println("\n平均值=" + (sum / arr.length));
//查找数组中是否有8->使用顺序查找
int findNum = 8;
int index = -1; //如果找到，就把下标记录到 index
for(int i = 0; i < arr.length; i++) {
if(findNum == arr[i]) {
System.out.println("找到数" + findNum + " 下标=" + i);
index = i;
break;
}
}
if(index == -1) {
System.out.println("没有找到数" + findNum );
}
}
}
21.创建类和对象
public class breakDemo {
public static void main(String []args) {
//实例化一个猫对象
//cat1是一个对象的名字
Cat cat1 = new Cat();
cat1.name = "小花";
cat1.age = 3;
cat1.color = "红色";
//访问对象的属性
System.out.print(cat1.name+"\t"+cat1.age);
}
}
//创建一个猫类
class Cat{
String name;
int age;
String color;
}
22.方法
public class Method01 {
//编写一个main方法
public static void main(String[] args) {
//方法使用
//1. 方法写好后，如果不去调用(使用)，不会输出
//2. 先创建对象 ,然后调用方法即可
Person p1 = new Person();
p1.speak(); //调用方法
p1.cal01(); //调用cal01方法
p1.cal02(5); //调用cal02方法，同时给n = 5
p1.cal02(10); //调用cal02方法，同时给n = 10
//调用getSum方法，同时num1=10, num2=20
//把 方法 getSum 返回的值，赋给 变量 returnRes
int returnRes = p1.getSum(10, 20);
System.out.println("getSum方法返回的值=" + returnRes);
}
}
class Person {
String name;
int age;
//方法(成员方法)
//添加speak 成员方法,输出 “我是一个好人”
//老韩解读
//1. public 表示方法是公开
//2. void ： 表示方法没有返回值
//3. speak() : speak是方法名， () 形参列表
//4. {} 方法体，可以写我们要执行的代码
//5. System.out.println("我是一个好人"); 表示我们的方法就是输出一句话
public void speak() {
System.out.println("我是一个好人");
}
//添加cal01 成员方法,可以计算从 1+..+1000的结果
public void cal01() {
//循环完成
int res = 0;
for(int i = 1; i <= 1000; i++) {
res += i;
}
System.out.println("cal01方法 计算结果=" + res);
}
//添加cal02 成员方法,该方法可以接收一个数n，计算从 1+..+n 的结果
//老韩解读
//1. (int n) 形参列表， 表示当前有一个形参 n, 可以接收用户输入
public void cal02(int n) {
//循环完成
int res = 0;
for(int i = 1; i <= n; i++) {
res += i;
}
System.out.println("cal02方法 计算结果=" + res);
}
//添加getSum成员方法,可以计算两个数的和
//老韩解读
//1. public 表示方法是公开的
//2. int :表示方法执行后，返回一个 int 值
//3. getSum 方法名
//4. (int num1, int num2) 形参列表，2个形参，可以接收用户传入的两个数
//5. return res; 表示把 res 的值， 返回
public int getSum(int num1, int num2) {
int res = num1 + num2;
return res;
}
}
23.方法返回多个数
public class breakDemo {
public static void main(String []args) {
Arr myArr = new Arr();
//用一个数组去接收
int Getme[] = myArr.method(1,2);
for(int i=0;i<Getme.length;i++){
System.out.println(Getme[i]);
}
}
}
class Arr{
public int[] method(int n1,int n2){
int [] arr = new int [2];
arr[0] = n1+n2;
arr[1] = n1-n2;
return arr;//返回一个数组
}
}
754
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
