本书的框架

java 返回数组中对应值的索引_java 返回数组中对应值的索引


基本数据类型与数组

  • 2.0 补充知识
  • 2.1 标识符与关键字
  • 2.1.1 标识符
  • 2.1.2 Unicode 字符集
  • 2.1.3 关键字
  • 2.2 基本数据类型
  • 2.2.0 Java数据类型前言
  • 2.2.1 整数型（整型）
  • 2.2.2 字符型
  • 2.2.3 浮点型
  • 2.2.4 布尔型/逻辑类型
  • 2.2.5 开辟空间练习
  • 2.3 类型转换运算
  • 2.4 输入与输出数据
  • 2.4.1 输出基本型数据
  • 2.4.2 输入基本数据
  • 2.5 数组
  • 2.5.1 声明数组
  • 2.5.2 为数组分配元素
  • 2.5.3 length 的使用
  • 2.5.4 数组的初始化
  • 2.5.5 数组的引用


2.0 补充知识

  1. Arrays类
  1. 介绍
  1. 可以进行创建、比较、排序、搜索、流操作以及其他的转换操作

2.1 标识符与关键字

2.1.1 标识符

  1. 自己理解：标识符就是文件名
  2. 标识符的语法规则
  1. 第一个字母是大写字母，大小写敏感
  2. 标识符由字母、下划线、美元符号和数字组成
  3. 标识符不能是关键字（就是Java关键字，可能以后编译错误就是标识符的问题，关键字是系统占用的文件名字）
  4. 标识符也不能是true、false和null

2.1.2 Unicode 字符集

  1. 自己理解：就是一个字典，每一个位置代表英文字母、汉字、日文、特殊符号等等
  2. Unicode是Java的标准字符集，最多可以识别65536个字符
  3. ASCII：使用 7 位二进制数来表示所有的大写和小写字母，数字 0 到 9、标点符号， 以及在美式英语中使用的特殊控制字符

2.1.3 关键字

  • 关键字的内容：abstract default goto* switch boolean do if package nchronzed break double implements private this byte else import protected throw throws case extends instanceof public transient catch int return char final interface short try class finally long static void const* float native strictfp volatile continue for new super while assert enum

2.2 基本数据类型






基本数据类型

整数类型

字符类型

浮点类型

逻辑类型


2.2.0 Java数据类型前言

  1. Java语言基本介绍
  1. 一些基本的语法命令介绍
public class Test{
		public static void main(String[] args){
			int x;
		}
	}
1. //两个斜杠是单行标识符
 2. /*这个是多行标识符*/
 3. 分号：语句的完结。
 4. public：公开其它类存取 
 5. class：类声明 Test类的名称
 6. void：代表没有返回值
 7. string：表示要传string的数组给此方法当参数，命名为args
 8. int x：这就是内容稍后再说
  1. System.out.println的加法运算、文件类型强转、括号的实验
public class Test3{
    public static void main (String args[]){
        char a,b,c,d,e;
        a='汉';
        System.out.println("汉字:"+a+"的位置是"+(int)a+'\n');//(int)a：将char型强转为int型
	    c='1';
    	d='2';
    	e='a';
    	System.out.println((int)c);                     //查看1在UTF-8中的位置
    	System.out.println((int)d);                     //查看2在UTF-8中的位置
    	System.out.println((int)e);                     //查看a在UTF-8中的位置
    	System.out.println('1'+'2');                    //用字符1和字符2相加，看看结果，就是位置序号相加
    	System.out.println('1'+'a');                    //用字符1和字符a相加，看看结果，就是位置序号相加
    	System.out.println(1+2);                        //1+2的运算
    	System.out.println("you"+1+2);                  //查看运算之前有字符还可不可以运算了
    	System.out.println(1+2+"you");                  //顺序颠倒
    	System.out.println(2+3+"you"+(1+2));            //标识符后边加括号就可以运算了
    	System.out.println("you"+"1+2");                //当做两个标识符罗列
    }
}
1. 如果想要强转文件类型要在变量前加入强转目标文件类型
 2. 一般情况下标识符后边不可以运算
 3. 标识符后边加括号就可以运算了
  1. Java各个类型中常量的存储方式（对应不同变量有固定的常量对其复制）

类型

类型名

常量说明

常量举例

整型

byte（1B）

一定范围的int常量（不超过字节数）

short（2B）

一定范围的int常量（不超过字节数）

int（4B）

int常量

二进制：0b101（0b或0B开头）；八进制：0456（0开头）；十进制：1234（正常写）；十六进制：0xA123（0x或0X）（a-f或A-F）

long（8B）

long型常量（在int型常量后加L或l）

二进制：0b101L（0b或0B开头）；八进制：0456L（0开头）；十进制：1234L（正常写）；十六进制：0xA123L（0x或0X）（a-f或A-F）

字符型

char（2B）

字符常量（用单引号）（占两个字节，存储每个字母的码值（就是给符号一个编号），一定范围的int型常量）0-65535

普通字符：‘A’,‘+‘等等。转义字符：’\n’（换行），‘\b’（退格），‘\t’（水平制表），‘’ ‘（单引号），’" ‘（双引号），’\uFFFF’（代表Unicode所对应码值的字符）等

浮点型

float（4字节）

单精度浮点型常量（后边必须加F或者f）

小数：12.0004F；科学计数法：4.3463E12f（E和e都行）

double（8字节）

双精度浮点型常量（后边必须加D或者d或者省略）

同上

布尔型

Boolean

布尔型常量

true、false

2.2.1 整数型（整型）

  1. 整型分类

整形类型

byte

short

int

long

字节

1

2

4

8

位数

8

2*8

4*8

8*8

  1. 整型类存储规则
  1. 最高位是符号位，0代表正数，1代表负数。eg：+5—>0
  2. 存储数据的步骤：先开辟空间（即占用指定整型的空间），再往指定空间内存储数据。
  3. 原码、反码、补码
  1. 原码
  1. 源码的规则：把原来的数字翻译成二进制的数字就是原码
  2. 原码的局限性：只适用于正数和正数相加，其他不适应
  1. 反码
  1. 反码的作用：保证在二进制下能够正常的进行正负数间的运算。
  1. 反码的规则：正数的反码就等于它本身，负数的反码是除去符号位其他位取反
  2. 反码的局限性：适用于正数和负数相加为负数，其他不行。
  3. 举例
  1. 用原码计算：0000 0011 + 1000 0101 = 1000 1000，结果是：-8
  2. 用反码计算：0000 0011+1111 1010=1000 0010.正确
  1. 补码
  1. 补码规则：负数的补码 = 反码 + 1。正数的补码就是原码。
  2. 补码解决的冲突：+0和-0的矛盾。
  1. 内存中整型都是用补码计算的

2.2.2 字符型

  1. 字符变量的规则
  1. 在使用char对变量赋值字符时等号后边需要时单引号并且每一个变量只能赋值一个字符（因为每一个字符在UTF-8中占2B，并且一个字符只有2B空间）
  2. 如果在赋值变量时输入的是数字就代表码值所对应的字符
  3. 如果运用字符进行运算得到的结果就是字符对应的码值的运算结果
  4. 转义字符：\uFFFF如果这么对char变量进行赋值输出的结果就是码值对应的字符（FFFF代表四位十六进制的数字正好是2B空间）

2.2.3 浮点型

  1. 浮点型的两种表达
  1. float型
  1. 常量：小数和指数表示方法，后缀必须有F或者f
  2. 变量：用float声明
  3. 存储时占8位有效数字，4个字节，占32位
  1. double型
  1. 常量：同上
  2. 变量：用double声明
  3. 存储时保留16位有效数字，分配8个字节内存，64位，
  1. 数据类型的转换
  1. 用int数据类型的常量也可以给浮点型赋值，只要是低精度给高精度或者同级别字符类型就可以互相赋值。
  1. 浮点型不准确存储
  1. 原理
  1. 存储时保留了固定的有效数字
  2. 存储到内存中就是以2的几次方存储
  1. 因为不能精确存储所以也不能画等号，只能比较大小
public class Test5{
    public static void main(String args[]){
        float a=1.2E3f;
        System.out.println(a);
        System.out.println(26.3==20+6.3);
  }
}

2.2.4 布尔型/逻辑类型

  1. Boolean型结果就是true或者false
public class Test4{
    public static void main(String args[]){
        boolean a=true;
        System.out.println(a);
    }
}

2.2.5 开辟空间练习

  1. int型应用
public class Test1{
	 public static void main(String[] args){
    	 int x,y;     //不能开辟带有运算符号的空间例如“x+y”，同理赋值的时候等号左边也不能带有运算符号，输出的时候也不能带有
	 			  //翻译：开辟空间“x,y”，并没有赋值即没有初始化，如果想要初始化可以这么写“int x=100”
     	 x=100;		  //翻译：给变量x赋值
     	 y=300;       //翻译：给变量y赋值
   	     System.out.println(x);		//翻译：输出x变量的值
   	     System.out.println(y);		//翻译：输出y变量的值
	  }
 }
  1. char型应用
public class Test2{
    public static void main(String args[]){
        char a='你';         //一个char型变量只能复制一个字符串，并且用单引号。不能复制两个字符串，因为一个变量占两个字节，且一个字符占两个字节，所以一个变量只能表示一个字符串。
        System.out.println(a);
    }
}
1. 一个char型变量只能复制一个字符串，并且用单引号。不能复制两个字符串，因为一个变量占两个字节，且一个字符占两个字节，所以一个变量只能表示一个字符串。
 2. 注意编码时使用的字符集是UTF-8

2.3 类型转换运算

  1. 数据类型精度从低到高排列
byte	short	char	int    long	   float    double
  1. 数据类型转换规则
  1. 档把低级别的变量的值赋给高级别变量时，系统自动完成数据类型的转换
eg：float x=100
  1. 当把高级别变量的值赋给低级别变量是，必须使用显示类型转换运算。
int x=(int)34.89（注意：同级别转换也归为这里。）
  1. 浮点型到整型转换直接截断，高精度到低精度保留低字节的。

2.4 输入与输出数据

2.4.1 输出基本型数据

  1. print输出语言
  1. print：直接输出内容
  2. println：输出内容并且换行
  3. printf
  1. 格式printf("格式控制符",表达式1，表达式2)
  2. 格式控制符
  1. %d：输出int型数据
  2. %c：输出char型数据
  3. %f：输出浮点型数据，小数部分最多保留6位
  4. %s：输出字符串
  5. %md：输出int型数据占m列
  6. %m.nf：输出的浮点型数据占m列，小数部分保留n位
  1. 举例
public class Test6{
    public static void main(String args[]){
    	float a=2;
    	System.out.printf("%10.4f",a);
	}
}

2.4.2 输入基本数据

  1. 输入的基本语言
  1. Scanner类
  1. 语法 Scanner reader=new Scanner(System.in);
  2. 实验
import java.util.Scanner;						//使用Scanner时必须要调用
public class Test7{
	public static void main(String args[]){
		int x;
		Scanner sc=new Scanner(System.in);
		x=sc.nextInt();
		System.out.println(x);
	}
}
···
  1. read命令调用的方法
  1. nextBoolean()
  2. nextByte()
  3. nextShort()
  4. nextInt()
  5. nextLong()
  6. nextFloat()
  7. nextDouble()

2.5 数组

2.5.1 声明数组

  1. 数组的用途：当想要建立多个数据空间时，不方便一一建立所以用到了数组。
  2. 数组的建立方式
  1. 一维数组：简单理解单个文件夹
int x[]; //声明了一个一维数组
int x[] y[]; //声明了两次一维数组
int [] a,b; //一起声明了两个一维数组
  1. 二维数组：简单理解文件夹组
int x[][]; //声明了一个二维数组
int x[][],y[][];  //声明了两个二维数组
int [][] x,y;  //一起声明了两个二维数组
int [] x,y[]；//声明了一个一维数组x和一个二维数组y

2.5.2 为数组分配元素

  1. 为数组分配元素的格式
数组名 = new 数组元素的类型[数组元素的个数]
eg:boy = new float[4]
  1. 在数组元素中存储数据
boy[0] = 12;
boy[1] = 12.1F;
  1. 声明数组和创建数组可以一起进行
float boy[] = new float[4];
  1. 数组存放的原理

2.5.3 length 的使用

a.length就是数组的长度

2.5.4 数组的初始化

float boy[] = {21.3f,23.89f,2.0f,23f,778.98f};相当于float boy[] = new float[5];+boy[0] = 21.3f;boy[1] = 23.89f,boy[2] = 2.0f,boy[3] = 23f,boy[4] = 778.98f;

2.5.5 数组的引用

  • 建立数组a、b
  • b=a把数组b赋值给a
注意现在数组变量a、b存放的元素收地址都为一个指向的都是同一个数组元素，更改元素a[0]和b[0]都改变