从线程和进程的角度来说,进程是资源分配的最小单位,线程是独立调度的最小单位。 同一个进程中的多个线程之间可以并发执行,他们共享进程资源。 线程不拥有资源,线程可以访问隶属进程的资源,进程有自己的独立空间地址,线程没有自己的独立空间地址,但是线程有自己的堆栈和局部变量。
命名方法:
类名 大写字母开头
方法 第一个单词为动词
尽量使用完整单词命名
快捷键:
输出语句快捷 sysout+Alt+/
代码块左移 全选中+shift+tab
变量类型:
类型 | 缺省值 | 长度 | 数的范围 |
---|---|---|---|
byte | 0 | 8位 | -128~127 |
short | 0 | 16位 | |
int | 0 | 32位 | |
long | 0 | 64 |
小数默认是double型,所以float =54.12报错,改为float=54.12f
boolean的缺省值是flase
String类型是Immutable的,一旦创建就不能够被改变
字面值:基本类型的赋值方式
基本类型是特殊类型,不是对象,不用new创建
数值X首部或尾部字母的意义:
XL long型
X 整型
0xX 16进制
0X 8进制
0bX 2进制
0f/0F float型
Xe2 X*100
public class HelloWorld {
public static void main(String[] args) {
long val = 26L; //以L结尾的字面值表示long型
int decVal = 26; //默认就是int型
int hexVal = 0x1a; //16进制
int oxVal = 032; //8进制
int binVal = 0b11010; //2进制
System.out.println(oxVal);
}
}
System.out.println(“test1\ttest2\rtest3\ntest4”);
\ 表转义
\t 制表符
\r 回车
\n 换行
打印" ’ \前加\ 例如,’ " ’
类型转换:
虽然short和char都是16位,也要强制转换
低精度向高精度转
高精度转为低精度时,若数值在低精度范围内,成功转型;否则数值出错(截断)
public class HelloWorld {
public static void main(String[] args) {
byte b = 5;
int i1 = 10;
int i2 = 300;
b = (byte) i1;
//因为i1的值是在byte范围之内,所以即便进行强制转换
//最后得到的值,也是10
System.out.println(b);
//因为i2的值是在byte范围之外,所以就会按照byte的长度进行截取
//i2的值是300,其对应的二进制数是 100101100
//按照byte的长度8位进行截取后,其值为 00101100 即44
b =(byte) i2;
System.out.println(b);
//查看一个整数对应的二进制的方法:
System.out.println(Integer.toBinaryString(i2));
}
}
整型和整型进行运算的时候,如果两边的值都是小于或者等于int的,那么其结果就是int。
所以要(short)进行强制类型转换
public class CategoryConvert {
static short a=1;//方法外的变量必须用static修饰,这样就不用创建对象
static short b=2;
public static void main(String[] args) {
// TODO Auto-generated method stub
short c=(short) (a+b);
}
}
命名规则:
变量命名只能使用字母 数字 $ _
变量第一个字符 只能使用 字母 $ _
变量第一个字符 不能使用数字
- int a_;
- int a@;X
- int a3;
- int 8@;X
- int 9_;X
- int X$_;
- int y;
- int $;X
- int KaTeX parse error: Expected group after '_' at position 1: _̲;
- int ∗ * ∗;X
- int 1 1 1;
- int 1;
- int @;X
- int a#;X
- int a";X
- int 123a";X
- int 123a_;X
- int $123b_;
变量声明位置 | 名称 |
---|---|
类下面 | 字段 、属性、成员变量、Field |
方法上 | 参数 |
方法内 | 局部变量 |
new Access().method1(5);//不用实名变量,临时调用类中的方法
当一个变量被final修饰的时候,该变量只有一次赋值的机会
public class HelloWorld {
public void method1() {
final int i = 5;
i = 10; //i在第4行已经被赋值过了,所以这里会出现编译错误
}
}
一个;也是一个表达式
{}为一个块
运算+输入:
public class calcu {
public static void main(String[] args) {
// TODO Auto-generated method stub
int i;
int j;
Scanner in=new Scanner(System.in);
i=in.nextInt();
j=in.nextInt();
System.out.println(i+j);
}
}
如果有任何运算单元的长度超过int,那么运算结果就按照最长的长度计算
int a;long b;a+b 为long
如果任何运算单元的长度都不超过int,那么运算结果就按照int来计算
byte a;byte b;a+b 为int
自增:
int i = 1;
int j = ++i + i++ + ++i + ++i + i++;
j=10错 答案:j=18
逻辑运算符:
长路与& 两侧,都会被运算
短路与&& 只要第一个是false,第二个就不进行运算了
public class HelloWorld {
public static void main(String[] args) {
//长路与 无论第一个表达式的值是true或者false,第二个的值,都会被运算
int i = 2;
System.out.println( i== 1 & i++ ==2 ); //无论如何i++都会被执行,所以i的值变成了3
System.out.println(i);
//短路与 只要第一个表达式的值是false的,第二个表达式的值,就不需要进行运算了
int j = 2;
System.out.println( j== 1 && j++ ==2 ); //因为j==1返回false,所以右边的j++就没有执行了,所以j的值,还是2
System.out.println(j);
}
}
长路或| 两侧都会被运算
短路或|| 只要第一个是true的,第二个就不进行运算了
取反!
异或^
int i = 1;
boolean b = !(i++ == 3) ^ (i++ ==2) && (i++==3);
答:!(false)^(false)&&(false)=false i=4 错
标答:变量后的自增符在判断符后运行
i值 2 3
表达式 1!=3 false->!(false)=true ; 2=2 true ; ->true^true=false 又因为&&为短路与,左边已为false,所以右边不运算,最终i=3
i+=++i;
答:++i先自增,i=2,i=i+i=4 错
标答:i=2+i 等号后的i=1,先保存到寄存器;若是i=++i + i ,i=4
位运算:
不用乘号算2*2^n:
2<<n
三元运算符: a>b?a:b
Scanner:
在通过nextInt()读取了整数后,再接着读取字符串,读出来的是回车换行:"\r\n",因为nextInt仅仅读取数字信息,而不会读取回车换行"\r\n".
调试:https://how2j.cn/k/debug/debug-debug-eclipse-java/1337.html
一行行执行 F6
数组:
声明数组:int a[] 或 int[] a
创建数组:a=new int[5]
声明+创建:int[] a=new int[5]
.length属性 0~数组长度-1
数组初始化:
int[] a = {1,2,3,4,5};//方法一
int[] b=new int[] {1,2,3,4,5};//方法二
int[] b=new int[5] {1,2,3,4,5};//错,创建数组时初始化,不能指定数组长度
练习——数组反转
public class Array {
static void print(int[] a,int n)
{
for(int i=0;i<n;i++) {
System.out.print(a[i]+" ");
}
}
public static void main(String[] args) {
int[] a = new int[5];
for(int i=0;i<5;i++)
a[i]=(int) (Math.random()*100);
print(a,5);
for(int i=0;i<2;i++)
{
int temp=a[i];
a[i]=a[4-i];
a[4-i]=temp;
}
System.out.println("\n转变后的:");
print(a,5);
}
}
练习——冒泡排序
将未排序的最小的数放在前
public class Array {
static void print(int[] a,int n)
{
for(int i=0;i<n;i++) {
System.out.print(a[i]+" ");
}
}
public static void main(String[] args) {
int[] a = new int[5];
for(int i=0;i<5;i++)
a[i]=(int) (Math.random()*100);
print(a,5);
for(int i=0;i<5;i++)
for(int j=i+1;j<5;j++)
{
if(a[i]>a[j])
{
int temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
System.out.println("\n转变后的:");
print(a,5);
}
}
增强型for循环
只能读,不能修改数组
for(int each:a)//取最大值
{
if(each>max)
ax=each;
}
数组长度确定后不能改
复制数组函数:
System.arraycopy(src, srcPos, dest, destPos, length)
src: 源数组
srcPos: 从源数组复制数据的起始位置
dest: 目标数组
destPos: 复制到目标数组的起始位置
length: 复制的长度
生成5-10间的随机数:(int)(Math.random()5)+5
a-b间: (int)(Math.random()(b-a))+a
合并数组:
public static void main(String[] args) {
int len1,len2;
len1=(int)(Math.random()*5)+5;
len2=(int)(Math.random()*5)+5;
int[] a = new int[len1];
int[] b = new int[len2];
for(int i=0;i<len1;i++)
a[i]=(int) (Math.random()*100);
print(a);
for(int i=0;i<len2;i++)
b[i]=(int) (Math.random()*100);
print(b);
int[] c=new int[len1+len2];
System.arraycopy(a, 0, c, 0, len1);
System.arraycopy(b, 0, c, len1, len2);
print(c);
}
二维数组:
public class HelloWorld {
public static void main(String[] args) {
//初始化二维数组,
int[][] a = new int[2][3]; //有两个一维数组,每个一维数组的长度是3
a[1][2] = 5; //可以直接访问一维数组,因为已经分配了空间
//只分配了二维数组
int[][] b = new int[2][]; //有两个一维数组,每个一维数组的长度暂未分配
b[0] =new int[3]; //必须事先分配长度,才可以访问
b[0][2] = 5;
//指定内容的同时,分配空间
int[][] c = new int[][]{
{1,2,4},
{4,5},
{6,7,8,9}
};
}
}
public static void main(String[] args) {
int[][] a=new int[][] {{2,3},{3,4}};//不指定长度,但必须先初始化
int[][] b=new int[3][];//可以先不指定第二维度的长度
b[0]=new int[2];
b[0][1]=1;//第二维度长度确定好后才能赋值
}
Array
针对数组的工具类,可以进行 排序,查找,复制填充等功能。
1、数组复制
copyOfRange(int[] original, int from, int to)
第一个参数表示源数组
第二个参数表示开始位置(取得到)
第三个参数表示结束位置(取不到)
类比:
System.arraycopy(Object src,int srcPos,Object dest,int destPos,int length))
但Object不能是二维数组
public static void main(String[] args) {
int[] a=new int[] {1,2,3,4,5};
int[] b=Arrays.copyOfRange(a, 0, 3);//数组b只声明,未创建
for(int each:b)
System.out.print(each+" ");
}
2、转换为字符串
Arrays.toString(int[] a)
public static void main(String[] args) {
int[] a=new int[] {1,2,3,4,5};
String s=Arrays.toString(a);
System.out.print(s);//输出[1, 2, 3, 4, 5]
}
3、排序
Arrays.sort(int[] a)
小到大排序
4、搜索
查询元素出现的位置
需要注意的是,使用binarySearch进行查找之前,必须使用sort进行排序
如果数组中有多个相同的元素,查找结果是不确定的
public static void main(String[] args) {
int[] a=new int[] {46,34,74,8,90};
Arrays.sort(a);
System.out.print(Arrays.binarySearch(a, 34));//输出1
}
5、判断是否相同
Arrays.equals(int[] a,int[] b)
6、填充
使用一个值填充整个数组
Arrays.fill(int[] a,int val)
public static void main(String[] args) {
int[] a=new int[10];
Arrays.fill(a, 5);
System.out.print(Arrays.toString(a));//输出[5, 5, 5, 5, 5, 5, 5, 5, 5, 5]
}
练习——二维数组排序
首先定义一个5X8的二维数组,然后使用随机数填充满。
借助Arrays的方法对二维数组进行排序。
参考思路:
先把二维数组使用System.arraycopy进行数组复制到一个一维数组
然后使用sort进行排序
最后再复制回到二维数组。
public static void main(String[] args) {
int[][] a=new int[5][8];
//二维数组随机赋值
for(int i=0;i<5;i++)
for(int j=0;j<8;j++)
a[i][j]=(int)(Math.random()*10);
System.out.println("排序前的二维数组:");
//以字符串形式按行输出二维数组
for(int i=0;i<a.length;i++)
System.out.println(Arrays.toString(a[i]));
//开辟一维数组存放二维数组
int[] b=new int[a.length*a[0].length];
//将二维数组的值按行赋给一维数组
for(int i=0;i<a.length;i++) {
System.arraycopy(a[i],0,b,i*a[0].length,a[0].length);
}
//一维数组排序
Arrays.sort(b);
//将排好序的一维数组重新赋值给二维数组
for(int i=0;i<a.length;i++) {
System.arraycopy(b,i*a[0].length,a[i],0,a[0].length);
}
System.out.println("排序后的二维数组:");
//以字符串形式按行输出排好序的二维数组
for(int i=0;i<a.length;i++)
System.out.println(Arrays.toString(a[i]));
}