2021年07月11日

发表于 分类于 ， ， Waline： 本文字数： 5.8k 阅读时长 ≈ 5 分钟

bit,Byte

1Byte=8bit

32位系统和64位系统的区别

32位的电脑的内存只能使用2^32Byte的内存，也就是32位的电脑最多使用4GB的内存条。

32位处理器一次只能处理32位，也就是4个字节的数据；而64位处理器一次就能处理64位，即8个字节的数据。 如果将总长128位的指令分别按16位、32位、64位为单位进行编辑的话：32位的处理器需要4个指令，而64位处理器则只要两个指令。 显然，在工作频率相同的情况下，64位处理器的处理速度比32位的更快。

内存以字节编址

指针的大小都是一样的

编码 原码 反码 补码

第一位表示符号, 其余位表示值.

比如如果是8位二进制:

1
2
[+1]原 = 0000 0001
[-1]原 = 1000 0001

反码

  • 正数的反码是其本身
  • 负数的反码是在其原码的基础上, 符号位不变，其余各个位取反.

补码

补码的表示方法是:

  • 正数的补码就是其本身
  • 负数的补码是在其原码的基础上, 符号位不变, 其余各位取反, 最后+1. (即在反码的基础上+1)

补码的补码就是原码

[+17]补码+[-5]补码=
[+17]补码+[-25]补码=

计算机数值范围8位机器：
-128~+127

-0(指代位-128)
8位机器：
+127+1=-128

32位机器的数值范围

-2^(31)~2^(31)-1

32位机器上最小数-2等于多少。

自己写个框架，然后实现，面试好吹牛。

计算机如何表示浮点数

数据类型

int
float
double
char

ASCII码

A-Z
a-z
0-9

声明变量
int m
变量命名规则：

C语言变量名命名规则

  • 只能取字母，数字，下划线
    • 不能以数字开头
  • 大小写敏感

Java语言

  • 只能取字母，数字，下划线，美元符号$

int m=60;
m=62
问
m=？
答：62

一次定义多个变量

1
int a,b,c;

算数运算符号

加+,减-,乘*,除/,求余数%

输入命令行

Scanner scanner=new Scanner(System.in);

m=scanner.nextInt();

输出

System.out.println();
System.out.println(“Hello”+m);

eclipse使用示例

打开
创建工程
创建包
创建主类

编程题，输入一个三位数，颠倒顺序

颠倒整数顺序

Upside down integer order

eclipse自动补全
eclipse字体调整

逻辑和条件

条件运算符
与&&、或||，非！

如下代码中：
10<=a<=30
c语言中是没有问题的
java语言中是不可以的
(10<=a)<=30
(boolean)<=int
不同类型无法比较，所以错误

条件式：

1
2
3
if(条件式){
    多条语句;
}
1
2
3
4
5
6
if(){

}
else{

}

错误写法

1
2
3
if(xxxx);{
    xxxx
}

编程题，闰年判断闰年

  • 能被4整数不能被100整除
  • 能被400整除

编程题 整数百分数，转等级

百分制分数转换为等级制分数

Percentage score conversion to a grade score

编程题switch 整数百分数，转等级

编程题 输入年月日 判断它是该年的第几日 判断是否为闰年

循环结构

1
2
3
for(表达式1;条件式;表达式2){
    语句块；
}

错误写法：

1
2
3
for(表达式1;条件式;表达式2);{
    语句块；
}

编程题

求阶乘
n!=n*(n-1)…32*1

s=1
s=s2
2=s3

Factorial.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
 * 求阶乘
 * @author 18190
 *
 */
public class Factorial {
	public static void main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		System.out.print("输入n:");
		int n=scanner.nextInt();
		int accumulate=1;
		for(int i=1;i<=n;i++) {
			accumulate=accumulate*i;
		}
		System.out.println(n+"的阶乘为："+accumulate);
	}
}
1
2
输入n:2
2的阶乘为：2
1
2
输入n:3
3的阶乘为：6
1
2
输入n:35
35的阶乘为：0

求水仙花数（100~999）

所谓的水仙花数是指：一个 n 位数 ( n≥3 )，它的每个位上的数字的 n 次幂之和等于它本身。例如153，370，371，407等都是水仙花数，就拿153来说，153 = 111 + 555 + 333.

输出所有的“水仙花数”，所谓的“水仙花数”是指一个三位数其各位数字的立方和等于该数本身，例如153是“水仙花数”，因为：153 = 1^3 + 5^3 + 3^3。

Narcissistic number
153=1^3+5^3+4^3

i++和++i的区别

while循环

判断一个数是否为素数

什么时候用for,什么时候有while

循环次数已知的就用for循环，
遍历次数为未知的就用while循环。

单行注释
块注释

编程题

计算根号a

编程题

pi/4=1-1/3+1/5-1/7+1/9-…+1/n
pi/4=

-1/3+1/5-1/7+1/9-…+1/n
-3=21+1
5=22+1
-7=2*3+1

(-1)^(i%2)/(2*i+1)

当算到1/n<10^(-6)=1e-6

丑数

把只包含质因数2，3，5的数称作丑数

1是第一个丑数。

UglyNumber.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
 * 把只包含质因数2，3，5的数称作丑数
 */
public class UglyNumber {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.print("输入一个数:");
		int n = scanner.nextInt();
		int temp = n;
		while (n % 2 == 0)
			n = n / 2;
		while (n % 3 == 0)
			n = n / 3;
		while (n % 5 == 0)
			n = n / 5;
		if (n == 1)
			System.out.println(temp + "是丑数");
		else {
			System.out.println(temp + "不是丑数");
		}
	}
}

素数

问号表达式

1
(条件表达式1)?值1:值2

for循环中的变量尽量在循环体内定义。
拆分整数

数组

a[下标]

定义数组

1
2
int a[]
int[] a;

内存划分

栈空间

栈空间占用的内存，生命周期结束则回收。

堆空间

堆空间的内存由垃圾回收机制回收。

new运算符

堆空间 的内存由new运算符来申请。

new申请的空间，对于数值类型的数据，都赋值为0

内存图

圆圈表示栈空间，方块表示堆空间。

浅拷贝

1
2
int[] a=new int[10];
int[] b=a;

数组长度

1
a.lenth

编程题 在数组中查找最大值最小值

从键盘中输入10个数，并找出最大最小值。

FindMaxAndMinInArray.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class FindMaxAndMinInArray {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int[] a = new int[10];
		System.out.print("输入10个数:");
		for (int i = 0; i < a.length; i++) {
			a[i] = scanner.nextInt();
		}
		int maxIndex = 0, minIndex = 0;
		for (int i = 1; i < a.length; i++) {
//			如果找到一个更大的数
			if (a[i] > a[maxIndex]) {
				maxIndex = i;
			}
//			如果找到一个更小的数
			if (a[i] < a[minIndex]) {
				minIndex = i;
			}
		}
//		输出最大最小值
		System.out.println("最大值：" + a[maxIndex] + "，最小值：" + a[minIndex]);
	}
}

动态初始化

1
2
3
4
5
int[] a=new int[10];
a[0]=1;
...
a[9]=10;

静态初始化

1
int a[]={1,2,3,4,5,6};

编程题 逆序存储到数组

ReverseStoredInTheArray.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
 * 逆序存储到数组中
 *
 */
public class ReverseStoredInTheArray {

	public static void main(String[] args) {
		int[] a=new int[10];
		Scanner scanner=new Scanner(System.in);
		for (int i = 0; i < a.length; i++) {
			a[a.length-1-i]=scanner.nextInt();
		}
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i]+" ");
		}
	}
}

编程题 逆序存储静态数组，首位交换

AxisymmetricStaticArray.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class AxisymmetricStaticArray {
	public static void main(String[] args) {
		int[] a = { 1, 2, 3, 4, 5, 6, 7, 8, 9,10 };
//		轴对称数组
		for (int i = 0, temp = 0; i < a.length / 2; i++) {
//			保存前面的数
			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] + " ");
		}
	}
}

编程题 十进制转为二进制，顺序输出

十进制整数转换为二进制整数十进制整数转换为二进制整数采用”除2取余，逆序排列“法。
具体做法是：
用2整除十进制整数，可以得到一个商和余数；
再用2去除商，又会得到一个商和余数，
如此进行，直到商为小于1时为止，然后把先得到的余数作为二进制数的低位有效位，后得到的余数作为二进制数的高位有效位，依次排列起来。

789=1100010101(B)

算式 余数 顺序
789/2=394 余1 第10位
394/2=197 余0 第9位
197/2=98 余1 第8位
98/2=49 余0 第7位
49/2=24 余1 第6位
24/2=12 余0 第5位
12/2=6 余0 第4位
6/2=3 余0 第3位
3/2=1 余1 第2位
1/2=0 余1 第1位
ConvertDecimalToBinary.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/**
 * 十进制转为二进制
 */
//  11/2 =5----1 
//  5 / 2=2----1 
//  2 / 2=1----0 
//  1 / 2=0----1
public class ConvertDecimalToBinary {
	public static void main(String[] args) {
//		被除数
		int dividend = 11;
		System.out.print("(" + dividend + ")10=");
//		定义保存余数的数组
		int[] remainders = new int[20];
//      定义商
		int quotient;
//		余数的计数器
		int remainderCounter = 0;
		do {
//			求商
			quotient = dividend / 2;
//			求余数
			remainders[remainderCounter] = dividend % 2;
//			本次的商作为下次的被除数
//			除数和被除数的区分方法是：在除法算式中，除号后面的数叫做除数，除号前面的数叫做被除数。
			dividend = quotient;
			remainderCounter++;
		} while (dividend > 0);
		System.out.print("(");
		for (int i = remainderCounter - 1; i >= 0; i--) {
			System.out.print(remainders[i]);
		}
		System.out.print(")2");
	}
}