Stay hungry,stay foolish.

1. 简述Java中内存分配的问题
   • 凡是new() 出来的东西，都是堆中进行分配的
   • 局部变量【数据类型+变量名】都是在栈中进行分配的
   • 静态变量【static】和字符串常量【”String”】都是在数据区进行分配的
   • 方法【代码】都是在代码区进行存放的
2. 简述Java中Object类的地位
   • Java中所有的类【自己定义的类以及Sun公司提供的类】都默认自动继承了Obeject类
   • Java中所有的类都从Object类中继承了toString()方法、hashCode()方法和equals等方法
     阅读全文 »

法一

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

//求出最大年龄,求出最小年龄,求出平均年龄
        int[] ages = {34,11,45,23,16};
        boolean flag = true ;
        for (int i = 4; flag && i >0 ; i--) {
            flag = false ;
            for (int j = 0; j < i; j++) {
                if(ages[j]>ages[j+1]){
                    int temp = ages[j];
                    ages[j] = ages[j+1];
                    ages[j+1] = temp ;
                    flag = true ;
                }
            }
            System.out.println("-------");
        }
        for (int i = 0; i < 5; i++) {
            System.out.print(ages[i]+ "\t");
        }

原理：%取最后一位，/取整除掉最后一位

逐行输出

1
2
3
4
5
6

int t = 12345 ;
while(t>0){
            int num = t%10;
            t /= 10 ;
            System.out.print(num);
        }

一次性输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14

int num = 12345;
		/*
			num%10       					5
			num/10%10    					4
			num/100%10   num/10/10%10 		3
			num/1000%10  num/10/10/10%10     2
			num/10000%10 num/10/10/10/10%10 1
		*/
		int result=0;
		while(num>0){
			result = result*10+num%10;
			num/=10;
		}
		System.out.print(result);

观点一

并行（parallelise）同时刻（某点），并发（concurrency）同时间（某段）

观点二

深入理解计算机系统CSAPP的回答。并发（Concurrency）是说进程B的开始时间是在进程A的开始时间与结束时间之间，我们就说A和B是并发的。并行（Parallel Execution）是并发的真子集，指同一时间两个进程运行在不同的机器上或者同一个机器不同的核心上。

关键难点：内循环的条件判断

1
2
3
4
5
6
7
8
9

public static void main(String[] args) {
        //九九乘法表
        for(int i = 1 ;i<=9;i++){
            for(int j = 1;j<=i;j++){
                System.out.print(j+"*"+i+"="+j*i+" ");
            }
            System.out.println("\n");
        }
    }

内存分配策略

按照编译原理的观点,程序运行时的内存分配有三种策略,分别是静态的,栈式的,和堆式的.
静态存储分配是指在编译时就能确定每个数据目标在运行时刻的存储空间需求,因而在编译时就可以给他们分配固定的内存空间.这种分配策略要求程序代码中不允许有可变数据结构(比如可变数组)的存在,也不允许有嵌套或者递归的结构出现,因为它们都会导致编译程序无法计算准确的存储空间需求.
栈式存储分配也可称为动态存储分配,是由一个类似于堆栈的运行栈来实现的.和静态存储分配相反,在栈式存储方案中,程序对数据区的需求在编译时是完全未知的,只有到运行的时候才能够知道,但是规定在运行中进入一个程序模块时,必须知道该程序模块所需的数据区大小才能够为其分配内存.和我们在数据结构所熟知的栈一样,栈式存储分配按照先进后出的原则进行分配。
静态存储分配要求在编译时能知道所有变量的存储要求,栈式存储分配要求在过程的入口处必须知道所有的存储要求,而堆式存储分配则专门负责在编译时或运行时模块入口处都无法确定存储要求的数据结构的内存分配,比如可变长度串和对象实例.堆由大片的可利用块或空闲块组成,堆中的内存可以按照任意顺序分配和释放.

问题一：

String str1 = “abc”;
String str2 = “abc”;
System.out.println(str1==str2); //true

问题二：

String str1 =new String (“abc”);
String str2 =new String (“abc”);
System.out.println(str1==str2); // false

问题三：

String s1 = “ja”;
String s2 = “va”;
String s3 = “java”;
String s4 = s1 + s2;
System.out.println(s3 == s4);//false
System.out.println(s3.equals(s4));//true
由于以上问题让我含糊不清，于是特地搜集了一些有关java内存分配的资料,以下是网摘：

1、 java程序的组成：

关键字，标识符，注释，变量，语句，表达式，数组，方法

2、 关键字：

Java语言内部使用了的一些用于特殊用途的词汇，那么在程序中用户不能使用。语言本身保留了一些词汇用于语言的语法等用途。

3、 已用到的关键字：

class 声明一个类。
public: 表示该类可以被外界调用 如果一个类被声明为public,那么该类所在的文件名要和类名一致。编译后的文件名和类名相同。
static:表示是静态的。
void：表示没有返回值

1、为什么需要变量？

方便对一个数据的修改和使用。如：一个数据在多处使用时，如果要修改，那么多个地方同时都需要修改，这个需要一个变量用于存储数据，在使用时，直接使用变量即可，这样当修改数据时，只需要修改变量本身的值就可以了。

2、什么是变量？

在java中，变量是一个存储空间的表示。

3、使用变量的语法：

数据类型 变量名 = 值

4、数据类型

基本可以分为两类：基本数据类型和引用数据类型
基本数据类型：整数、小数、布尔、字符