01-JAVA快速入门（廖雪峰）

最新推荐文章于 2023-12-27 19:10:03 发布

小夏天禧

最新推荐文章于 2023-12-27 19:10:03 发布

阅读量805

点赞数

分类专栏： java学习

本文链接：https://blog.csdn.net/qq_24573381/article/details/108640010

版权

java学习专栏收录该内容

31 篇文章 0 订阅

订阅专栏

01-Java快速入门

一、Java简介

学习java的原因：

目前全球Top1开发语言
应用于企业和互联网后端开发、Android开发、大数据开发
市场需求最大的软件工程师
便于学习其他语言

Java特点：

一种面向对象的跨平台编程语言
以字节码方式运行在虚拟机上
自带功能齐全的类库
非常活跃的开源社区支持

Java优点：

简单、健壮、安全
跨平台，一次编写，到处运行
高度优化的虚拟机

Java缺点:

语法较繁琐
无法直接操作硬件不适合底层系统的开发
GUI效果不佳不适合桌面应用的开发

Java应用范围

适用于：

企业和互联网后端开发
Android移动app开发
大数据应用开发

不适用于：

底层操作系统开发无法直接操作硬件
桌面应用程序开发 JavaGUI可以跨平台，针对平台特性比较差
桌面大型游戏开发需要显卡的支持，需要直接操作硬件

课程体系：

Java SE系列课程 Java开发基础
Java EE系列课程企业和互联网后端开发
Android系列课程 Android移动app开发

课程目标：

全面深入掌握Java平台开发能力(面向对象编程、核心类库使用、多线程)
培养架构思维和自我学习能力(模块化开发、设计模式、如何学习开源项目等)
培养优秀工程习惯和编码能力(良好的项目结构、IDE技巧、代码格式、调试方法等)

Java的版本：

Java的规范：

JSR规范: Java Specification Request
JCP组织: Java Community Process
确保Java跨平台特性

Java的平台：

二、安装JDK

安装后打开命令提示符检查java命令：

java -version
java

检查javac命令：

javac

需要把JDK的bin目录添加到环境变量Path中

此电脑--属性--高级系统设置--环境变量--Path--编辑--插入jdk在计算机中的地址

三、第一个java程序

public class Hello {
    public static void main(String[] args){
        System.out.println("Hello,world!");
    }
}

C:\Users\asus>cd Desktop

C:\Users\asus\Desktop>javac Hello.java

C:\Users\asus\Desktop>java Hello

Hello,world!

四、安装并使Eclipse

安装Eclipse(java IDE):

各种配置如图所示：

1.Myeclipse设置字体

打开软件，点击“Windows”-“Preference”；在搜索框中输入“font”，回车，点击“colors and fonts”。点击“Text Font”，点击“Edit”。弹出对话框中可以进行字体的各种设置，设置完成后点击“确定”。

2.Myeclipse设置自动补全

Window ——> Preferences ——> Java --> Editor --> Content Asist，在Auto activation triggers for Java后面的文本框里只有一个“.”。将其改为“.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ”即可。注意不要漏掉前面的.点号。

3.Myeclipse安装插件

Help---Install from Site--Name: feiyangedu

Location: http://static.feiyangedu.com/eclipse/site.xml

接受协议

重启Eclipse

4.Myeclipse强制关闭

点击键ctrl+shfit+esc键

5.自动格式化

Ctrl + shift +F

五、安装Eclipse插件

02-Java程序基础

一、Java程序基本结构

/**
*可以用来创建文档的注释
*
*/
public class Hello {
    public static void main(String[] args){
        //向屏幕输出文本
        System.out.println("Hello,world!");
        /*多行注释开始
        注释内容
        注释结束*/
    }
}//class定义结束

1.类名

类名必须是英文字母、数字和下划线的组合
类名必须是以英文字母开头
要注意遵守命名习惯

好的命名：Hello NoteBook VRPlayer

不好的命名:hello,Good123,Note_Book,_World

2.方法命名

public class 类名 {
    public static void 方法名（参数） {

    }
}

方法名首字母小写

好的命名：main goodMorining playVR

不好的命名:Main good123 good_moring _playVR

3.注释

Java的注释的种类

单行注释
多行注释
特殊的文档注释/** **/可用于自动创建文档

在代码最顶端输入/**再回车，eclipse将会自动创建文档注释

/**
 * 
 * @author asus
 *
 */
public class Hello {

    public static void main(String[] args) {
	// 向屏幕输出文本；
	System.out.println("Hello,world");
	/*多行注释开始
        注释内容
        注释结束*/
    }
}//class定义结束

二、变量和数据类型

1.变量

变量是可以持有某个基本类型的数值，或者指向某个对象。
变量必须先定义后使用
定义变量：变量类型变量名 = 初始值;
变量可以重新赋值

2.java基本数据类型

整数类型：long int short byte
浮点类型：double float
布尔类型：boolean
字符类型：char

计算机内存的最小存储单元是字节byte
一个字节是8位二进制数：00000000-11111111（0-255）
内存单元从0开始编号，称为内存地址
1K=1024字节，1M=1024K，1G=1024M，1T= 1024G
Java的byte和计算机的byte是对应的。Java分正负数

数据类型

整型：

byte：1个字节，8位，2^7~2^7-1即128～127
short：2个字节，16位，2^15~2^1-1即-32768～32767
int：个字节，32位，2^32~2^32-1，二进制 int i2 = 0b10000（二进制用0b开头） 16进制 int j16 = 0xff0000 2147483648（16进制用0x开头）
long：8个字节，64位，2^64~2^64-1，long类型数字加L，如long l = 9000000000000L

浮点型：

float：4个字节，32位，float f1 = 3.14f; float f2 = 3.14e38f;
double：8个字节，64位double d = -1.79e308; double d1 = 4.9e-324;

布尔类型：

boolean只有true和false2个值

字符类型：

char字符类型：保存一个字符，用单引号表示char c1 = 'A'; char c2 = '中';

Eclipse Debug

进入调试模式后可以设置断点后单步执行--双击在要执行的行打点--单步执行--执行结束-resume--然后切换到java的窗口

Debug--双击在要执行的行打点--单步执行--执行结束-resume--然后切换到java的窗口

3.常量

常量就是用final修饰的变量，便于更好的理解程序的意图

变量初始化后不可再次赋值
常量名通常全部大写
常量用来避免意外赋值
常量用来代替Magic Number 如税率TAX = 0.2;每次使用tax，易读性更好。

代码示例

public class Assiggnmet {

    public static void main(String[] args) {
	int n = 100;
	System.out.println(n);
	n = 200;
	System.out.println(n);
	int x = n;
	System.out.println(x);
	x = x + 100;
	System.out.println(x);
	System.out.println(n);
    }

}

public class IntType {

    public static void main(String[] args) {
	byte b =127;
	short s = 32767;
	int i =2147483647;
	long l = 9000000000000000L;
	System.out.println(b);
	System.out.println(s);
	System.out.println(i);
	System.out.println(l);
		
	int i3 = 2_000_000_000;
	int i4 = 0xff0000;
	int i5 = 0b10000000;
	System.out.println(i3);
	System.out.println(i4);
	System.out.println(i5);
		
	//输出十六进制表示的整型
	System.out.println(Integer.toHexString(12345678));
	//输出二进制表示的整型
	System.out.println(Integer.toBinaryString(12345678));

    }
}

public class Constant {

    public static void main(String[] args) {
	final double PI = 3.1415;
	double r =4.0;
	double length = PI * r *2;
	double area = PI * r * r;
	System.out.println(length);
	System.out.println(area);
		
	//magic number;
	final double TAX_RATE = 0.2;
	double salary = 12500.0;
	double pay = salary *(1-TAX_RATE);
	System.out.println(pay);
    }

}

三、整数运算

1.运算规则

基于四则运算规则
除法结果为整数
除数为0运行时将报错
++运算和--运算
简写的+=和-=
取余运算%

2.整数运算：

计算结果溢出不报错
计算结果是不正确的
解决方法：用范围更大的整型。

3.移位运算：

左移<<
带符号右移>>
不带符号右移>>>（）
byte和short会先转换为int再进行移位

4.位运算：

&与运算：都是1才为1
|或运算：其中一个为1就为1
亦或运算^不相同结果为1
非运算～ ~ 1 = 0, ~ 0 = 1

5.整型运算优先级：

6.类型自动提升与强制转型

在运算过程中，计算结果为较大类型的整型
可以将结果强制转型：(类型)变量或数值。
强制转型可能丢失精度。long类型是64位，强制转为int类型，会将高位抛弃

代码示例

public class Div {

    public static void main(String[] args) {
	int i = 99 / 9;
	System.out.println(i);//0
	//整数运算的结果仍然是整数；
	//int n = 100 / 0;//报错
	//后面的语句不会执行；
	//System.out.println(z);
		
	//++运算和 --运算
	int p = 0;
	int a = p++;//先赋值再运算 0
	int b = ++p;//先运算再赋值 2
	System.out.println(a);//0
	System.out.println(b);//2
		
	//+=运算和-=运算
	int n = 3309;
	System.out.println(n+=100);//3409
	System.out.println(n-=100);//3409
	System.out.println(n%100);//9
		
	//计算结果溢出
	int q = Integer.MAX_VALUE;
	System.out.println(q);//2147483647
	int x = q + 1;
	System.out.println(x);//-2147483648
	long y =(long)q + 1;
	System.out.println(y);//2147483648
		
	//移位运算
	int n1 = 5;
	String s1 = Integer.toBinaryString(5);
	System.out.println("5的二进制:"+s1);//5的二进制:101
	System.out.println();
		
	int n2 = n1 << 10;//左移10位，在后面加10个0
	String s2 = s1 + "0000000000";//字符串加10个0，得到二进制字符串
	//101~对字符串左移10位~1010000000000	转换为10进制数:5120
	System.out.println(s1+"~对字符串左移10位~"+s2+"\t转换为10进制数:"+Integer.parseInt(s2,2));
	//直接左移10位:n2=5120
	System.out.println("直接左移10位:n2="+n2);
	System.out.println();
	
	int n3 = n2 >> 11;//右移11位，去掉11个0
	String s3 = "10";//s2=1010000000000去掉后面的11位数
	//1010000000000~右移10位10	2
	System.out.println(s2+"~右移10位"+s3+"\t"+Integer.parseInt(s3,2));
	//直接右移11位:n3=2
	System.out.println("直接右移11位:n3="+n3);
	System.out.println();
		
	int n4 = n1 << 29;//最高位是符号，1表示符号，0表示整数
	//5直接左移29位：-1610612736
	System.out.println(n1+"直接左移29位："+n4);
        System.out.println();
		
        
	int n5 = n4 >> 29;//保留符号位右移
	String s5 = "10";//s2=1010000000000去掉后面的11位数
	//-1610612736直接右移29位：-3
	System.out.println(n4+"直接右移29位："+n5);
	System.out.println();
	int n6 = n4 >>> 29;//无条件右移
	//-1610612736无条件右移11位：5
	System.out.println(n4+"无条件右移11位："+n6);
		
	//位运算
	int y1 = 0x03_83_d0_25;
	int y2 = 0x00_00_ff_ff;
	int y3 = y1 & y2;
	int y4 = y1 | y2;
	System.out.println(y3);//53285
	System.out.println(y4);//58982399
	System.out.println(Integer.toBinaryString(y1));//11100000111101000000100101
	System.out.println(Integer.toBinaryString(y2));//1111111111111111
	     System.out.println("n1&n2:"+Integer.toBinaryString(y3));//n1&n2:1101000000100101
	    System.out.println("n1|n2:"+Integer.toBinaryString(y4));//n1|n2:11100000111111111111111111
	
	//类型自动提升与强制转型
	short s = 12;
	int x1 = 100 + s;
	long x2 = 999 * x1;
	//int x = n - 199;//编译错误
	int u1 = (int)(x2- 199);
	int u2 = (int)x2 - 199;
	int u3 = (int)(x2 * 100000000);
	System.out.println(u1);//111689
	System.out.println(u2);//111689
	System.out.println(u3);//410193920
	    
    }
}

四、浮点数运算

1.浮点数运算的特点

很多浮点数无法精确表示
计算有误差
整型可以自动提升到浮点型
注意类型不能自动提升的情况

2.特殊值

NaN表示Not a Number
Infinity表示无穷大
-Infinity表示负无穷大

3.强制转型

浮点型强制转为整型会直接扔掉小数位
四舍五入的技巧，+0.5
超出整型范围自动变为最大值

代码示例

public class FloatOps {

    public static void main(String[] args) {
	double a = 0.1;
	double b = 1 - 9.0/10;
	System.out.println(a);//0.1
	System.out.println(b);//0.09999999999999998
		
	//注意没有自动提升的情况
	double d1 = 1.2 + 24.0/5;
	double d2 = 1.2 + 24/5;
	System.out.println(d1);//6.0
	System.out.println(d2);//5.2
		
    }

}

public class NaN {

    public static void main(String[] args) {
	double d1 = 0.0/0;
	double d2 = 1.0/0;
	double d3 = -1.0/0;
	System.out.println(d1);//NaN
	System.out.println(d2);//Infinity
	System.out.println(d3);//-Infinity

    }

}

public class ToInt {

    public static void main(String[] args) {
	int n1 = (int)12.3;
	int n2 = (int)12.7;
	int n3 = (int)(12.7+0.5);
	int n4 = (int)1.2e20;
	System.out.println(n1);//12
	System.out.println(n2);//12
	System.out.println(n3);//13
	System.out.println(n4);//2147483647
    }

}

五、布尔运算

关系运算符：>， >=， <， <=， ==，!=
与运算 &&
或运算 |
非运算！

三元运算符

根据条件b计算x或y b ? x : y
x和y只计算其中一个
x和y类型必须相同

代码示例

public class Cond {

    public static void main(String[] args) {
	int n = 5;
	boolean t = n > 0;
	boolean f = n < 0;
	boolean isFive = n == 5;
	boolean isNotFive = n != 5;
		
	boolean and = t && f;
	boolean or = t || f;
	boolean not = !t;
	System.out.println(t);//true
	System.out.println(f);//false
	System.out.println(isFive);//true
	System.out.println(isNotFive);//false
	System.out.println(and);//false
	System.out.println(or);//true
	System.out.println(not);//false

    }

}

public class ShortCircuit {

    public static void main(String[] args) {
	int n = 0;
	boolean and = (5 < n) && (5 / n > 0);
	boolean or = (5 > n) || (5 / n > 0);
	System.out.println(and);//false,只看一个，一个是false结果必然false
	System.out.println(or);//true
    }
}


public class Main {

    public static void main(String[] args) {
	//利用三元运算符求绝对值
	int n = 199;
	boolean positive = n >= 0;
	int abs = positive ? n : -n;
	System.out.println(abs);//199
    }
}

六、字符和字符串

1.字符类型char

char是基本的数据类型
char：保存一个字符，如英文字符、中文字符。
Java使用unicode表示字符，可以将char赋值给int类型，查看字符对应的unicode编码。
使用16进制的unicode编码定义字符

2.字符串类型

字符串类型是引用类型：

String：保存一个字符串
转译字符\
常见转译字符：\n \" \r \t \\

字符串操作

字符串连接用+
可以连接字符串和其他数据类型字符串

字符串是引用类型

字符串不是基本类型
字符串是引用类型
字符串不可变
引用类型是变量指向某个对象，而不是持有某个对象。

空值

所有的引用类型都可以指向空值null，即不指向任何对象。

空字符串和空值不一样，空字符串是一个字符串

代码示例

public class CharType {

    public static void main(String[] args) {
	char c1 = 'A';
	char c2 = '中';
	int n1 = c1;
	int n2 = c2;
	//注意十六进制
	char c3 = '\u0041';
	char c4 = '\u4e2d';
	System.out.println(n1);//65
	System.out.println(n2);//20013
	System.out.println(c3);//A
	System.out.println(c4);//中
    }

}
public class Str {

    public static void main(String[] args) {
	String s1 = "ABC";
	String s2 = "中文str";
	String s3 = "Hello\n";
	String s4 = "\"Hello\"";
	System.out.println(s1.length());//3
	System.out.println(s2.length());//5
	System.out.println(s3.length());//6
	System.out.println(s4.length());//7
		
	String s = "hello";
	System.out.println(s);//hello
	String h ="hello,"+"world!";
	System.out.println(h);//hello,world!
	String a = "age is "+ 12;
	System.out.println(a);//age is 12
		
	//空值不同于空字符串
	String u = null;
	System.out.println(u);//null
	String v = "";
	System.out.println(v);

    }

}

public class Ref {

    public static void main(String[] args) {
	String q = "hello";
	System.out.println(q);//hello
	String t = q;
	System.out.println(t);//hello
	q = "world";
	System.out.println(q);//world
	q = "Hello," + q;
	System.out.println(q);//Hello,hello
	System.out.println(t);//hello

    }

}

七、数组

当有一组类型相同的变量时，可以用数组表示

数组的特点：

数组类型是“类型[]”
数组初始化用new int[5]
数组所有元素初始化为默认值
数组创建后大小不可改变
数组索引从0开始
数组是引用类型，数组大小不可变
- 使用索引（下标）访问数组元素
- 索引超出范围将会报错
可以指定初始化元素，由编译器自动推算数组大小
进一步简写{......}
数组元素是值类型（如int[]）或引用类型（如String[]）

代码示例

public class Hello {

    public static void main(String[] args) {
	//5位同学的成绩：
	//int[] ns = new int[] {68,79,91,86,62};//可以指定初始化元素，由编译器自动推算数组大小
	//进一步简写
	//int[] ns = {68,79,91,86,62};
	int[] ns = new int[5];
	ns[0] = 68;
	ns[1] = 69;
	ns[2] = 45;
	ns[3] = 79;
	ns[4] = 98;
	System.out.println(ns.length);//5
	System.out.println(ns[2]);//45
	//System.out.println(ns[5]);//超出范围报错
	//数组本身不变，大小不变，只是创建了新的对象
	//ns = new int[] {1,2,3};
	String[] names = {"xiaoming","xiaohong","xaiojun"};
	System.out.println(names[2]);//xaiojun

    }

}

public class Main {

    public static void main(String[] args) {
	int[] ns1 = new int[5];
	int[] ns2 = new int[]{1,3,5,7,9};
	int[] ns3 = {2,4,6,8,10};
	int[] ns4 = ns3;
	System.out.println("ns1.length:"+ns1.length);//ns1.length:5
	System.out.println("ns2.length:"+ns2.length);//ns2.length:5
	System.out.println("ns3.length:"+ns3.length);//ns3.length:5
	//现在ns3和ns4指向同一个数组
	System.out.println("ns3[1]:"+ns3[1]);//ns3[1]:4
        ns3[1] = 999;
        System.out.println("ns3[1]:"+ns3[1]);//ns3[1]:999
        System.out.println("ns4[1]:"+ns4[1]);//ns4[1]:999

    }

}

03-流程控制

一、输入和输出

1.输入

导入java.util.Scanner
创建Scanner对象并传入System.in
使用Scanner.nextLine()读取用户输入的字符串
Scanner.nextInt()读取用户输入的整数

import java.util.Scanner;

public class Hello {

    public static void main(String[] args) {
	Scanner scanner = new Scanner(System.in);
	System.out.println("input your name:");
	String name = scanner.nextLine();
	System.out.println("input your age:");
	int age = scanner.nextInt();
	System.out.println("Hi,"+name + ", your age "+ age);
    }
}

2.输出

        System.out.println("输出换行");
        System.out.print("输出但不换行");

格式化输出

格式化输出使用System.out.printf()
使用占位符%xxx
常用的占位符

%d	整数
%x	十六进制整数
%f	浮点数
%s	字符串
%%	%字符本身

public class Output {

    public static void main(String[] args) {
	double d = 3.1415926;
	System.out.println(d);//3.1415926
	System.out.printf("PI = %.2f\n",d);//PI = 3.14
	System.out.printf("PI = %7.2f\n",d);//PI =    3.14
	//格式化小数
	double f = 0.123456;
	System.out.printf("%f\n",f);//0.123456
	System.out.printf("%e\n",f);//1.234560e-01(科学计数法)
	System.out.printf("%.2f\n",f);//0.12
	System.out.printf("%6.2f\n",f);//  0.12
	System.out.printf("%+.2f\n", f);//打印符号位+0.12
        //调整参数顺序
        System.out.printf("%s %s %s \n", "A", "B", "C");//A B C 
        System.out.printf("%2$s %1$s %1$s %3$s\n", "A", "B", "C");//1$s表示第一个参数B A A C
        //System.out.printf("%s %s","A", "B");//参数可以多，但不能少。少了会报异常java.util.MissingFormatArgumentException

    }

}

搜索java Format String Syntax，即可找到更多格式化输出参数说明。

https://docs.oracle.com/javase/8/docs/api/java/util/Formatter.html

二、if判断

1.if条件判断的格式

使用If(条件){......}
根据计算结果（true还是false）决定是否执行语句块
语句块可以包含多语句
只有一条执行语句可以省略{}（不推荐）
else不是必须的

if (条件) { 代码块 }
if (条件) { 代码块1 } else { 代码块2 }
if (条件1) { 代码块1 } else if { 代码块2 } else { 代码块3 }

2.整型判断

要注意判断顺序
要特别注意边界条件

3.浮点数判断

浮点数用== 判断不靠谱
可以利用差值小于某个临界值来判断将if (x==0.1)改为if (Math.abs(x-0.1) < 0.0001)

4.引用类型判断

引用类型 == 判断是否指向同一对象
equals()判断内容是否相等
如果变量为null，调用equals()会报错
解决办法
- 利用短路运算符&&
- 把非null的对象放在前面

代码示例

public class IfElse {

    public static void main(String[] args) {
	int n = 70;
	if (n>=90) {
	    System.out.println("优秀");	
	}else if(n>=60){
	    System.out.println("及格了");	
	}else {
	    System.out.println("挂科了");
	}
    }
}

public class IfFloat {

    public static void main(String[] args) {
	double x = 1 - 9.0/10;
	if (Math.abs(x-0.1) < 0.0001) {
	    System.out.println("x is 0.1");//x is 0.1
	}else {
	    System.out.println("x is NOT 0.1");
	}
	System.out.println("x= " + x);//x= 0.09999999999999998

    }
}

public class IfString {

    public static void main(String[] args) {
	String s1 = "hello";
	String s2 = "HELLO".toLowerCase();
	if (s1==s2) {
	    System.out.println("s1==s2");		
	}
	if (s1.equals(s2)) {
	    System.out.println("s1.eaquals(s2)");
	}
    }

}

三、switch多重选择

switch语句

根据switch(表达式)跳转到匹配的case结果，

继续执行case结果: 的后续语句,

遇到break结束执行，

无匹配时执行default语句

import java.util.Scanner;

public class Hello1 {

    public static void main(String[] args) {
	Scanner scanner = new Scanner(System.in);
	System.out.println("Select 1-4");
	int opt = scanner.nextInt();
	switch (opt) {
	    case 1:
		System.out.println("Selected 1");
		break;
			
	    case 2:
	    case 3:	
		System.out.println("Selected 2,3");
		break;
			
	    case 4:
		System.out.println("Selected 4");
		break;

	    default:
		System.out.println("Not Selected");
	    }
	    System.out.println("END");
    }
}

四、while循环

循环语句就是让计算机根据条件做循环计算

条件满足时循环，条件不满足时退出循环

while循环

while循环首先判断条件：
条件满足时循环；条件不满足时退出循环
可能一次都不循环。如while false

避免死循环

当循环条件永远满足时变成死循环
死循环导致CPU 100%占用
要避免编写死循环代码

逻辑错误循环

public class Main1 {

    public static void main(String[] args) {
	int sum = 0;
	int n = 1;
	while (n<10) {
	    sum = sum + n;
	    n++;
	}
	System.out.println(n);//10
	System.out.println(sum);//45
    }
}

五、do-while循环

do-while先执行循环，再判断条件。
条件满足时继续循环；条件不满足时退出；至少循环1次

public class Main2 {

    public static void main(String[] args) {
	int sum = 0;
	int n = 1;
	do {
	    sum = sum + n;
	    n++;
	} while (n<10);
	System.out.println(n);//10
	System.out.println(sum);//45
    }
}

六、for循环

for循环

for循环使用计数器实现循环
计数器变量通常命名为i
for循环条件分别设置：计数器初始值；循环前检测条件；每次循环后如何更新计数器
初始化计数器总是被执行的
for循环可能循环0次
不要在循环体内修改计数器，计数器变量尽量定义在for循环中
for循环可以缺少初始化条件、循环条件和每次循环更新条件。通常不推荐这样写，容易产生死循环，如
for(int i=0; ;i++)
for(int i=0; ; )
for( ; ; )

for each循环

for each循环能够遍历数组和可迭代数据类型，包括List、Map等
for each循环无法指定遍历顺序
for each循环无法获得数组索引
同时遍历多个数组时，无法使用for each循环

public class Main3 {

    public static void main(String[] args) {
	int[] ns = {1,4,9,16,25};
	for (int i = ns.length-1; i >=0; i--) {
	    System.out.println(ns[i]);
	}
    }
}

public class Main4 {

    public static void main(String[] args) {
	int[] ns = {1,4,9,16,25};
	for (int n : ns) {
		System.out.println(n);
	}
    }

}

七、break和continue

在循环过程中，可以使用break语句跳出循环。
break语句总是跳出最近的一层循环
continue可以提前结束当前循环，直接继续下次循环

public class Break {

    public static void main(String[] args) {
	int[] ns = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
	int sum = 0;
	for (int i = 0; i < ns.length; i++) {
	    if (i == 5) {
		System.out.println("break");
	    }
	    System.out.println("add ns[" + i +"]");
	    sum = sum + ns[i];	
	}
	System.out.println(sum);
		/**
		 * add ns[0]
		 * add ns[1]
		 * add ns[2]
		 * add ns[3]
		 * add ns[4]
		 * break
		 * add ns[5]
		 * add ns[6]
		 * add ns[7]
		 * add ns[8]
		 * add ns[9]
		 * add ns[10]
		 * add ns[11]
		 * add ns[12]
		 * add ns[13]
		 * add ns[14]
		 * 120
		 * 
		 */

    }

}

public class Continue {
    //对奇数进行求和
    public static void main(String[] args) {
	int[] ns = {31,21,22,73,79,56,7,83,19,12,53,84,68};
	int sumOfOdds = 0;
	for (int n : ns) {
	    if (n%2==0) {
	        System.out.println("skip "+ n);
	        continue;	
	    }
	    sumOfOdds = sumOfOdds + n;
	}
	System.out.println(sumOfOdds);

    }
}
/**
 * skip 22
 * skip 56
 * skip 12
 * skip 84
 * skip 68
 * 366
 * **/

04-数组操作

一、遍历数组

for循环通过下标遍历数组
for each直接遍历数组所有元素
直接打印数组变量，得到的是数组在JVM中的引用地址
for each循环打印也很麻烦
Arrays.toString（）也可以快速打印数组内容

import java.util.Arrays;

public class Main1 {

    public static void main(String[] args) {
	int[] ns = {1,1,2,3,5,8};
	System.out.println(ns);
	System.out.println(Arrays.toString(ns));

    }

}
[I@15db9742
[1, 1, 2, 3, 5, 8]

二、数组排序

1.冒泡排序法

将第一个值和后面的值，挨个比较，如果手里的值比序列的值小，就交换数据，拿新的数字继续比较，直到最后。
再将第二个值和后面的值，挨个比较。
循环往复，排序完成。

注意：交换两个变量的值必须通过一个临时变量

2.使用jdk的Arrays.sort()直接排序

sort对大数组进行快速排序，对小数组仍使用冒泡排序

3.查看源码

使用鼠标左击，即可查看源码。
如果没有jdk源码，只要将Attach Source——External Location添加jdk源码即可。
windows：在jdk的根目录下
Mac：jdk1.8.0_131.jdk/Contents/Home/下3.

import java.util.Arrays;

public class Main2 {

    public static void main(String[] args) {
	int[] ns = {28,12,89,73,65,18,96,50,8,36};
	//排序前
	System.out.println(Arrays.toString(ns));
	//排序
	for (int i = 0; i < ns.length; i++) {
	    for (int j = i + 1; j < ns.length; j++) {
	        if (ns[i] > ns[j]) {
	            //交换ns[i]和ns[j]:
	            int temp = ns[j];
	            ns[j] = ns[i];
	            ns[i] = temp;
					
	        }
				
            }
        }
    System.out.println(Arrays.toString(ns));
    }

}

import java.util.Arrays;

public class Main3 {

    public static void main(String[] args) {
        int[] ns = {28,12,89,73,65,18,96,50,8,36};
        //排序前
        System.out.println(Arrays.toString(ns));
        //排序
        Arrays.sort(ns);
        //排序后
        System.out.println(Arrays.toString(ns));

    }

}

三、多维数组

二维数组

二维数组就是元素为数组的数组
二维数组每个数组的长度不要求一样
访问二维数组使用 array[row][col]
二维数组每个数组元素的长度并不要求相同

三维数组

三维数组是每个元素都是一个二维数组

import java.util.Arrays;

public class Main4 {

    public static void main(String[] args) {
	int[][] stds = {
	    //语文，数学，英语，体育
	    {68,79,95,81},
	    {91,89,53,72},
	    {77,90,87,83},
	    {92,98,89,85},
	    {94,75,73,80}
        };
	System.out.println(stds.length);
	System.out.println(Arrays.toString(stds));
	System.out.println(Arrays.deepToString(stds));
	for (int[] std:stds) {
	    int sum =0;
	    for (int s:std) {
	        sum = sum + s;
	    }
	    int avg = sum/std.length;
	    System.out.println("Average score:" + avg);
        }

    }

}
/**5
[[I@15db9742, [I@6d06d69c, [I@7852e922, [I@4e25154f, [I@70dea4e]
[[68, 79, 95, 81], [91, 89, 53, 72], [77, 90, 87, 83], [92, 98, 89, 85], [94, 75, 73, 80]]
Average score:80
Average score:76
Average score:84
Average score:91
Average score:80
**/

四、命令行参数

命令行参数是一个String[] 数组

由JVM接收用户输入并传给main(
根据参数执行不同的代码

public class Main5 {

    public static void main(String[] args) {
	System.out.println("Number of args:"+args.length);
	for (String arg:args) {
	    if ("-version".equals(arg)) {
	        System.out.println("version 1.0");
	    }
	    System.out.println(arg);
	}
    }
}
/**Number of args:4
version 1.0
-version
-s
-t
Hello world
**/

小夏天禧

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
01-JAVA快速入门（廖雪峰）

一、Java简介学习java的原因：目前全球Top1开发语言应用于企业和互联网后端开发、Android开发、大数据开发市场需求最大的软件工程师便于学习其他语言Java特点：一种面向对象的跨平台编程语言以字节码方式运行在虚拟机上自带功能齐全的类库非常活跃的开源社区支持Java优点：简单、健壮、安全跨平台，一次编写，到处运行高度优化的虚拟机Java缺点:语法较繁琐无法直接操作硬件不适合底层系统的开发 GUI效果不佳不适合桌面应用的...
复制链接

扫一扫