数据类型转义字符及其说明：”" 字符集：unicode；字符编码集；.基本数据类型之间的运算（不包含boolean类型）1.自动类型提升：2.强制类型转换：自动类型提升运算的逆运算。java中的运算符：1.算术运算符： 2.赋值运算符:7.三元运算符：程序流程控制顺序结构分支结构循环结构扩展关键字：break、continue的使用Java中的数组；二维数组;数组的赋值、反转、查找（线性查找(equals()),二分法查找{折半查找）数组中涉及到的常见算法：排序算法选择排序：交换排序插入排序归并排序桶式排序基数排序集合基础：集合和数组的特点对比：ArrayList集合：ArrayList的构造方法：ArrayList中常用的成员方法:ArrayList中添加元素的方法：ArrayList中删除元素的方法：ArrayList中修改元素的方法：ArrayList中查询元素：ArrayList中的元素个数：Arrays工具类的使用数组操作内存进制二进制：Ascanner中方法的使用扩展：
数据类型
-
基本数据类型：
-
数值类型：
-
整数类型：
-
byte
-
short
-
int
-
long （特殊提示：声明long型变量，必须以“L"或 "l"结尾）
-
-
浮点类型：
-
float （特殊提示：声明float型变量，必须以“f"或"F"结尾）
-
double:
-
-
-
字符型：char
-
char(1字符=2字节） char c="a";//用于数据类型的运算时代表的时97 char c="A"//65 b//96 B//64 a~z：从97往下减一， A~Z：从65往下减一；
-
-
布尔值：Boolean
类型 占用储存空间 表示数的范围 byte 1字节=8bit位 -128~127 short 2字节 -2的15次方到正的2的15次方 int 4个字节 long 8个字节
单精度float 4字节 -3.4.03E38~3.403E38 双精度double 8字节 -1.798E308~1.798E308
-
-
引用数据类型:类（class)、接口（interface)、 数组（[])\
转义字符及其说明：”" 字符集：unicode；字符编码集；
\b 退格符 \n 换行符 \r 回车符 \t 制表符 " 双引号 \’ 单引号 \ 反斜杠
.基本数据类型之间的运算（不包含boolean类型）
· 不同整数类型之间的运算：用于接收的声明变量类型等于或大于用运算中的最大字节。 浮点型的字节比整型的long大；
1.自动类型提升：
当容量小的数据类型的变量域容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。 byte、short、char-->int-->long-->float-->double 特殊：byte、short、char这三种类型做运算时结果为int类型；
2.强制类型转换：自动类型提升运算的逆运算。
1.需要使用强制转换符：（） 2.注意点：强制转换可能会导致精度损失。 eg: double d1=12.9; int i1=(int）d1;//截断操作-->12 --(精度损失） （精度损失2）： int i2=128; byte b=(byte)i2;//-128 默认类型：整型常量：默认类型为int型 浮点型常量：默认类型为double型 字符串：string属于引用数据类型；
字符串-->int : Integer.parseInt(字符串）
关于进制： 二进制：最高位代表符号位:0：正数；1：负数； 正数的源码、反码、补码都是一样的 负数的反码：除符号位外，各个位取反 补码：反码加一 计算机底层都是以 二进制转成十进制：乘以二的幂数 十进制转成二进制：除以2去余数。
java中的运算符：
1.算术运算符：
正号、负号、加、减、乘、除、%：取模（取余）、++：自增（前）：先运算后取值、 ++：自增（后）：先取值后运算、
--： · +：字符串连接
2.赋值运算符:
符号：= 扩展：+=，-=，*=,/=,%=;
-
++ 、--、+=不会改变变量本身的数据类型
eg:short s=10; s=s+1;//编译失败
//练习1
int i=1; i*=0.1; System.out.print(i);//0 i++; System.out.print(i);//1
//练习2
int m=2; int n=3; n*=m++; System.out.println("m="+m);//3 System.out.println("n="+n);//6//练习3
int n1=10; n1+=(n1++)+(++n1);//n1=n1+(n1++)+(++n1)-->n1=10+10+12=32 System.out.print(n1);//32
4.比较运算符
==、！=、<、>、<=、>= 返回结果（true或false）
5.逻辑运算符：
&—逻辑与 |—逻辑或 ！—逻辑非 &&—短路与 ||—短路或 ^—逻辑异或
（1）&与&&的区别：
&”与“&&”都表示逻辑与，两者判断顺序都是从左往右，输出的结果都是Boolean类型，他们的区别在于：
“&”会判断两个表达式，即使左边的等式是false，也仍然会继续判断右边的等式，在判断完两边的等式之后再输出结果。
“&&”相比较则更节省时间，当左边的等式结果是false时，就不对右边等式进行判断而直接输出结果。
（2）区分：|与||
相同点1：|与||的运算结果相同
相同点2：当符号左边是false时，二者都会执行符号右边的运算
不同点3：当符号左边时true时，|继续执行符号右边的运算，而||不再执行符号右边的运算。
6.位运算符：
<<:左移 ——3<<2=12-->3 * 2 * 2=12;
>>:右移——3>>1=1-->3/2=1;
>>>:无符号右移 ——3>>>1=1-->3/2=1
&:与运算——6&3=2
|:或运算——6|3=7、
^：异或运算——6^3=5
~:反运算：——~6=-7
//面试题：
class Test{
public static viod main(String[] args){
boolean x=true;
boolean y=false;
short z=42;
if((z++=42)&&(y=true))z++;
if((x=false)||(++z==45)){
z++;
}
System.out.println("z="+z);
}
}
//结果为:
z=46;
位运算符：直接对整数的二进制进行的运算
运算：<<:21<<2——21 *2 *2=84;
结论：在一定范围内，每向左移一位相当于乘于2（存在限度：只能移到该数据类型的二进制的追高位数）
运算：>>向右移：每向左移一位相当于除以2
>>:被移位的二进制最高位是0，右移后 ，空缺位都用0补。
>>>:被移位二进制最高位无论是0或者是1，空缺位都用0补。
&：二进制位进行&运算，只有1&1是结果是1，否则是0；
|：二进制位进行|运算，只有0|0时结果是0.否则时1；
7.三元运算符：
（1）结构：（条件表达式）？表达式1：表达式2；（表达式1和表达式2要求式一致的。)
（2)三目运算符可以嵌套使用的；
String maxStr=(m>n)?"m大"：((m==n))?"m和n相等"："n大");
程序流程控制
顺序结构
分支结构
if分支语句：（三种格式）
if(条件表达式){
执行代码块
}
if(条件表达式1){
执行代码块1
}else{
执行代码块2
}
if(条件表达式1){
执行代码块1
}else if(条件表达式2){
执行代码块2
}else{
执行代码块3
}
switch(表达式){
case 常量1：
语句1；
//break;
}
循环结构
-
for循环；
-
while循环的使用：
-
for循环和while循环是可以相互转换的！
-
两者的区别：for循环和while循环的初始化条件部分的作用范围不同。在for里面赋值在for外面不能引用。
-
-
do-while循环结构：
初始化条件
do{循环体；
迭代条件
}while(循环条件){ }
扩展
如何从键盘获取不同类型的变量：需要使用Scanner类
具体实现步骤：
-
导包：import java.util.Scanner;
-
Scanner的实例化：Scanner scan=new Scanner(System.in);
-
调用Scanner类的相关方法，来获取指定类型的变量。
//练习： //小明参加java考试，他和他父亲达成承诺： //如果： //成绩位100分时，奖励一辆BMW; //成绩位（80-90）时，奖励一台iphone xs max; //当成绩位[60,80]时。奖励一个ipad; //其他时，什么奖励也没有。 //请从键盘输入小明的期末成绩，并加以判断
import java.util.Scanner;
class SannerTest{
public static void main(String[] args){
Scanner scan=new Scanner(System.in);
System.out.println("输入小明的期末成绩");
int one=scan.nextInt();
if(one==100){
System.out.println("奖励一辆BMW;");
}else if(one>80&&one<90){
System.out.println("奖励一台iphone xs max;");
}else if(one>60&&one<80){
System.out.println("奖励一个ipad;");
}else{
System.out.println("什么也没有");
}
}
}
//如何获取随机数：
int value=(int)Math.random();
关键字：break、continue的使用
-
break:在switch-case或者循环结构中
-
continue:在循环结构中
区别：break:结束当前循环；
continue:结束当次循环
Java中的数组；
数组的常见概念（数组属于引用数据类型的变量）
-
数组名
-
下标（或索引）
-
元素
-
数组的长度
-
存储相同类型的一组数据。
数组的特点：
-
数组是有序排列的；
-
数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型。
-
创建数组对象会在内存中开辟一整块的连续空间
-
数组的长度一旦确定，就不能修改。
数组的初始化值;
public class HelloWorld {
public static void main(String[] args) {
//1.一维数组的声明和初始化
//1.1静态初始化：数组的初始化和数组的赋值操作同时进行
int[] ids =new int[] {1001,1002,1003,1004};
System.out.println("里哈吉");
//动态初始化：数组的初始化和数组元素的赋值操作分开运行
String[] manes=new String[5];
System.out.println(ids.length);
System.out.println(manes.length);
//总结：数组一旦初始化完成，其长度就确定了。
//错误写法：
// int[] arr1= new int[];
// int[5] arr2= nwe int[5];
//int[] arr3 = new int[3]{1,2,3},
}
}
数组元素的默认初始化值：（数组必须动态初始化才能使用）
-
数组元素是整型:0
-
数组元素是浮点型：0.0
-
数组元素是char类型：0或（'\u0000')
-
数组元素是Boolean型：false
-
数组是引用数据类型时：null （注意：不是"null"；
int [] arr=new int[4];
for(int i=0;i<arr.length;i++) {
System.out.println(arr[i]);//输出:0 0 0 0
}
数组的内存解析：（难点：
栈(stack)：主要存放局部变量，
堆(heap)：存放的数据是new 出来的结构：对象、数组
方法区：常量池、静态域、等等
二维数组;
//二维数组的使用：
//二维数组的初始化
//静态初始化
int[][] arr1= new int[][] {{1,2,3},{2,2,3}};
//动态初始化1：
int[][] arr2=new int[3][2];
//动态初始化2：
int[][] arr3=new int[3][];
//特殊写法：
int[] arr4[]=new int[][] {{1,2,3},{2,2,3}};
//二维数组的默认值：
int[][] arr3=new int[3][2]; System.out.println(arr3[0]);//地址值 Systen.out.println(arr3[0][0]);//0
-
针对于初始化方式一：比如：int [] [] arr=new int[4] [3]
-
外层元素的初始值为：地址值；
-
内层元素的初始值为：与一维数组初始情况一样。
-
-
针对初始化方式二：比如; int [] [] arr=new int [4] [];
-
外层元素的初始值为：null
-
内层元素的初始值为：不能调用，否则报错。
-
//数组内存分析：
//关于数组：
-
.写出一维数组初始化的两种方式：
-
写出二维数组初始化的两种方式：
-
.如何遍历如下的二维数组；
-
不同类型的一维数组元素的默认初始化值各是多少。
-
一维数组的内存解析；
//注意：两个变量之间的赋值
-
两个变量的数组类型要相同
-
两个变量之间存在自动类型提升
数组的赋值、反转、查找（线性查找(equals()),二分法查找{折半查找）
-
线性查找：
-
二分法查找：前提：所要查找的数组必须是有序。
数组中涉及到的常见算法：排序算法
选择排序：
直接选择排序、堆排序
交换排序
冒泡排序、快速排序
-
冒泡排序算法原理：重复地走访要排序的数列，一次比较两个数据元素，如果顺序不对则进行交换，并一直重复这样的走访操作，直到没有要交换的数据元素为止。
-
首先我们肯定有一个数组，里面存放着待排序的元素列表，我们如果需要把比较大的元素排在前面，把小的元素排在后面，那么需要从尾到头开始下面的比较操作：
-
从尾部开始比较相邻的两个元素，如果尾部的元素比前面的大，就交换两个元素的位置。
-
往前对每个相邻的元素都做这样的比较、交换操作，这样到数组头部时，第 1 个元素会成为最大的元素。
-
重新从尾部开始第 1、2 步的操作，除了在这之前头部已经排好的元素。
-
继续对越来越少的数据进行比较、交换操作，直到没有可比较的数据为止，排序完成。
-
-
-
快速排序：
-
初始化：pivot low high
-
插入排序
直接插入排序、折半插入排序、Shell排序
归并排序
桶式排序
基数排序
集合基础：
注意：打印String、StringBuilder、集合都不会出现对象名；
集合和数组的特点对比：
-
集合类的特点：提供一种存储空间可变的存储类型，存储的数据容量可以发生改变；
-
集合和数组的区别：、
-
共同点：都是存储数据的容器；
-
不同点：数组的容量是固定的，集合的容量是固定的；
-
ArrayList集合：
Class ArrayList<E>
-
可调整大小的数组实现：
-
<E>:是一种特殊的数据类型、泛型；
-
泛型类的数据类型不能是基本数据 类型；
-
泛型只能传入引用数据类型；
-
ArrayList的构造方法：
-
public ArrayList():创建一个空的集合对象
ArrayList中常用的成员方法:
ArrayList中添加元素的方法：
-
public boolean add(E e):将指定的元素追加到此集合的尾部
-
public void add(int index,E element):在此集合中的自定位置插入指定的元素
ArrayList<String> msg=new ArrayList<>(); boolean one =msg.add("123"); System.out.println(one);//true msg.add(0,"134"); System.out.println(msg);//[134,123]
ArrayList中删除元素的方法：
-
public boolean remove(Object o):删除指定的元素，返回删除是否成功
-
public E remove(int index):删除指定索引处的元素，放回被删除的元素
----接着上面------------ boolean ab=msg.remove("123"); System.out.println(ab);//true System.out.println(msg);//[134] msg.add("abc"); System.out.println(msg);//[134, abc] String two =msg.remove(0); System.out.println(two);//134 System.out.println(msg);//[abc]
ArrayList中修改元素的方法：
public E set(int index,E element):修改指定索引的元素，返回被修改的元素
-----接上------
msg.add("bbc");
System.out.println(msg);//[abc, bbc]
String bb=msg.set(1,"bb");
System.out.println(bb);//bbc
System.out.println(msg);//[abc, bb]
ArrayList中查询元素：
public E get(int index)：返回指定索引处的元素
String cc=msg.get(1); System.out.println(cc);//bb
ArrayList中的元素个数：
public int size() 返回集合中的元素个数：
int dd=msg.size(); System.out.println(dd);//2
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);//false
//2.String toString(int[] a);输出数组信息。
System.out.println(Arrays.toString(arr1));//[1, 2, 3, 4]
//3.void fill(int[] a,int val):将指定的值填充到数组当中；
Arrays.fill(arr1,10);
System.out.println(Arrays.toString(arr1));//[10, 10, 10, 10]
//4.int binarySearch(int[] a,int key):对数组进行排序。
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));
//5.int binarySearch(int[] a,int key)对排序后的数组进行二分法查找指定的值
int[] arr3=new int[] {99,20,40,80,100};
int index=Arrays.binarySearch(arr3, 99);
System.out.println(index);
数组操作
-
插入元素：
-
末尾插入；
-
首尾间插入用链表省时
-
-
删除元素：
-
删除掉数组中的某个元素后，数组中会留下空缺的位置，而数组中的元素在内存中是连续的，这就使得后面的元素需对该位置进行填补操作。
-
内存
栈内存：方法运行时，进入的内存，局部变量都存放于这块内存当中
堆内存：new 出来的内容都会进入堆内存，并且会存在地址值（堆内存的空间地址绝对不会出现两个相同的）
方法区：字节码文件（class文件）加载时进入的内存
进制
二进制：
-
进制规则：
逢二进一 -
错位规则：
借一还二
Ascanner中方法的使用
整数：int -->nextInt()
字符串：String -->next();遇到了空格，就不再路入数据了（结束标记:空格 tab键）
String-->nextLine();可以将数据完整的接收过来；
注意：nextInt和nextLine方法配合使用的时候，nextLine方法就没有键盘录入的机会了=
建议：今后键盘录入数据的时候，如果是字符串和整数一起接收，建议使用next方法接受字符串。
扩展：
-
计算机中你的时间原点为：1970年1月1日00：00：00；
14万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
