Java 知识点总结汇总_java entry的index作用-CSDN博客

本文链接：https://blog.csdn.net/hubin1989/article/details/77834075

最近想系统总结总结Java的一些知识点，以前有很多莫能两可的东西，只知道怎么用，但是原理的东西大多没有深入研究，这次就花时间总结一下。

1）int 和 Integer 的区别不只是一个是类，一个是基本类型。看如下代码：

12     public static void main(String[] args) {
13         int i = 128;
14         Integer i2 = 128;
15         Integer i3 = new Integer(128);
16         //Integer会自动拆箱为int，所以为true
17         System.out.println(i == i2);
18         System.out.println(i == i3);
19         System.out.println("**************");
20         Integer i5 = 127;//java在编译的时候,被翻译成-> Integer i5 = Integer.valueOf(127);
21         Integer i6 = 127;
22         System.out.println(i5 == i6);//true
23         /*Integer i5 = 128;
24         Integer i6 = 128;
25         System.out.println(i5 == i6);//false
26 */        Integer ii5 = new Integer(127);
27         System.out.println(i5 == ii5); //false
28         Integer i7 = new Integer(128);
29         Integer i8 = new Integer(123);
30         System.out.println(i7 == i8);  //false
31     }
32 
33 }

首先，17行和18行输出结果都为true,因为Integer和int比都会自动拆箱（jdk1.5以上）。

22行的结果为true,而25行则为false,很多人都不动为什么。其实java在编译Integer i5 = 127的时候,被翻译成-> Integer i5 = Integer.valueOf(127);所以关键就是看valueOf()函数了。只要看看valueOf()函数的源码就会明白了。JDK源码的valueOf函数式这样的：

1 public static Integer valueOf(int i) {
2         assert IntegerCache.high >= 127;
3         if (i >= IntegerCache.low && i <= IntegerCache.high)
4             return IntegerCache.cache[i + (-IntegerCache.low)];
5         return new Integer(i);
6     }

看一下源码大家都会明白，对于-128到127之间的数，会进行缓存（这一点很多人可能都不清楚），Integer i5 = 127时，会将127进行缓存，下次再写Integer i6 = 127时，就会直接从缓存中取，就不会new了。所以22行的结果为true,而25行为false。

对于27行和30行，因为对象不一样，所以为false。

总之就是：

①无论如何，Integer与new Integer不会相等。不会经历拆箱过程，前者的引用指向堆，而后者指向专门存放他的内存（常量池），他们的内存地址不一样，所以为false
  ②两个都是非new出来的Integer，如果数在-128到127之间，则是true,否则为false
  java在编译Integer i2 = 128的时候,被翻译成-> Integer i2 = Integer.valueOf(128);而valueOf()函数会对-128到127之间的数进行缓存
  ③两个都是new出来的,都为false
  ④int和integer(无论new否)比，都为true，因为会把Integer自动拆箱为int再去比

2）Map遍历的四种方法

// 第一种：
15         /*
16          * Set<Integer> set = map.keySet(); //得到所有key的集合
20          */
21         System.out.println("第一种：通过Map.keySet遍历key和value：");
22         for (Integer in : map.keySet()) {
23             //map.keySet()返回的是所有key的值
24             String str = map.get(in);//得到每个key多对用value的值
25             System.out.println(in + "     " + str);
26         }
27         // 第二种：
28         System.out.println("第二种：通过Map.entrySet使用iterator遍历key和value：");
29         Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();
30         while (it.hasNext()) {
31              Map.Entry<Integer, String> entry = it.next();
32                System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
33         }
34         // 第三种：推荐，尤其是容量大时
35         System.out.println("第三种：通过Map.entrySet遍历key和value");
36         for (Map.Entry<Integer, String> entry : map.entrySet()) {
37             //Map.entry<Integer,String> 映射项（键-值对）  有几个方法：用上面的名字entry
40             System.out.println("key= " + entry.getKey() + " and value= "
41                     + entry.getValue());
42         }
43         // 第四种：
44         System.out.println("第四种：通过Map.values()遍历所有的value，但不能遍历key");
45         for (String v : map.values()) {
46             System.out.println("value= " + v);
47         }
48     }

3）Java的内存分区，以及每个分区存放哪些数据

栈区：
栈分为java虚拟机栈和本地方法栈

重点是Java虚拟机栈，它是线程私有的，生命周期与线程相同。
每个方法执行都会创建一个栈帧，用于存放局部变量表，操作栈，动态链接，方法出口等。每个方法从被调用，直到被执行完。对应着一个栈帧在虚拟机中从入栈到出栈的过程。
通常说的栈就是指局部变量表部分，存放编译期间可知的8种基本数据类型，及对象引用和指令地址。局部变量表是在编译期间完成分配，当进入一个方法时，这个栈中的局部变量分配内存大小是确定的。
会有两种异常StackOverFlowError和 OutOfMemoneyError。当线程请求栈深度大于虚拟机所允许的深度就会抛出StackOverFlowError错误；虚拟机栈动态扩展，当扩展无法申请到足够的内存空间时候，抛出OutOfMemoneyError。
本地方法栈为虚拟机使用到本地方法服务（native）

堆区：

堆被所有线程共享区域，不是数据共享，在虚拟机启动时创建，唯一目的存放对象实例。
堆区是gc的主要区域，通常情况下分为两个区块年轻代和年老代。更细一点年轻代又分为Eden区最要放新创建对象，From survivor 和 To survivor 保存gc后幸存下的对象，默认情况下各自占比 8:1:1。
不过很多文章介绍分为3个区块，把方法区算着为永久代。这大概是基于Hotspot虚拟机划分，然后比如IBM j9就不存在永久代概论。不管怎么分区，都是存放对象实例。
会有异常OutOfMemoneyError

方法区：

被所有线程共享区域，用于存放已被虚拟机加载的类信息，常量，静态变量等数据。被Java虚拟机描述为堆的一个逻辑部分。习惯是也叫它永久代（permanment generation）
垃圾回收很少光顾这个区域，不过也是需要回收的，主要针对常量池回收，类型卸载。
常量池用于存放编译期生成的各种字节码和符号引用，常量池具有一定的动态性，里面可以存放编译期生成的常量；运行期间的常量也可以添加进入常量池中，比如string的intern()方法。

程序计数器：

当前线程所执行的行号指示器。通过改变计数器的值来确定下一条指令，比如循环，分支，跳转，异常处理，线程恢复等都是依赖计数器来完成。
Java虚拟机多线程是通过线程轮流切换并分配处理器执行时间的方式实现的。为了线程切换能恢复到正确的位置，每条线程都需要一个独立的程序计数器，所以它是线程私有的。
唯一一块Java虚拟机没有规定任何OutofMemoryError的区块

4）stack 和 heap的区别

1) Heap是 Stack的一个子集.（扩展—>从内存观点考虑）

2) Stack存取速度仅次于寄存器，存储效率比heap高，可共享存储数据，但是其中数据的大小和生存期必须在运行前确定。

3) Heap是运行时可动态分配的数据区，从速度看比Stack慢，Heap里面的数据不共享，大小和生存期都可以在运行时再确定。

4) new关键字是运行时在Heap里面创建对象,每new一次都一定会创建新对象，因为堆数据不共享。

比如： String str1= new String("abc"); (1)

String str2= "abc"; (2)

str1是在Heap里面创建的对象。

str2是指向Stack里面值为“abc”的引用变量，语句(2)的执行，首先会创建引用变量str2, 再查找Stack里面有没有“abc”，有则将 str2指向 “abc”,没有则在Stack里面创建一个“abc”,再将str2指向“abc”。

由此可终结为在建立一个对象时从两个地方分配内存，在堆中分配的内存实际建立这个对象，而在栈中分配的内存只是一个指向这个堆对象的指针(引用)而已。

Stack（栈）是JVM的内存指令区（主要存放的都是指针/引用）。Stack管理很简单，push一定长度字节的数据或者指令，Stack指针压栈相应的字节位移；pop一定字节长度数据或者指令，Stack指针弹栈。Stack的速度很快，管理很简单，并且每次操作的数据或者指令字节长度是已知的。所以Java 基本数据类型，Java 指令代码，常量都保存在Stack中。
Heap（堆）是JVM的内存数据区（主要存放是对象实例）。Heap 的管理很复杂，每次分配不定长的内存空间，专门用来保存对象的实例。在Heap 中分配一定的内存来保存对象实例，实际上也只是保存对象实例的属性值，属性的类型和对象本身的类型标记等，并不保存对象的方法（方法是指令，保存在 Stack中）,在Heap 中分配一定的内存保存对象实例和对象的序列化比较类似。而对象实例在Heap 中分配好以后，需要在Stack中保存一个4字节的Heap 内存地址，用来定位该对象实例在Heap 中的位置，便于找到该对象实例。

由于Stack的内存管理是顺序分配的，而且定长，不存在内存回收问题；而Heap 则是随机分配内存，长度不定，存在内存分配和回收的问题；因此在JVM中另有一个GC进程，定期扫描Heap ，它根据Stack中保存的4字节对象地址扫描Heap ，定位Heap 中这些对象，并且假设Heap 中没有扫描到的区域都是空闲的，统统refresh（实际上是把Stack中丢失了对象地址的无用对象清除了）这里顺便简单的描述下GC的机制。GC机制很复杂，具体的以后在详细描述。

经常会有一些装逼的面试官会问JVM的工作原理等等，下面简单说下，操作系统装入JVM是通过jdk中Java.exe来完成,。通过下面4步来完成JVM环境，分为如下四步：

1.创建JVM装载环境和配置----创建环境

2.装载JVM.dll ------装载

3.初始化JVM.dll并挂界到JNIENV(JNI调用接口)实例 ----初始化

4.调用JNIEnv实例装载并处理class类，用通俗的解释就是：执行程序

下面在说说JVM的体系结构
我们首先要搞清楚的是：什么是数据以及什么是指令。然后要搞清楚对象的方法和对象的属性分别保存在哪里。
1）方法本身是指令的操作码部分，保存在Stack中；
2）方法内部变量作为指令的操作数部分，跟在指令的操作码之后，保存在Stack中（实际上是基本的数据类型保存在Stack中，对象类型在Stack中保存地址，在Heap 中保存值）；上述的指令操作码和指令操作数构成了完整的Java 指令。
3）对象实例包括其属性值作为数据，保存在数据区Heap 中。
非静态的对象属性作为对象实例的一部分保存在Heap 中，而对象实例必须通过Stack中保存的地址指针才能访问到。因此能否访问到对象实例以及它的非静态属性值完全取决于能否获得对象实例在Stack中的地址指针。

基本数据类型保存在Stack中，那么大家会有疑问，String保存在哪里？，下面解释下String是如何保存的。举例说明：

String 是放在字符串池（常量池）中
只有通过new String("");方式创建的字符串才会放在堆中
如果是通过String str = "abc";这样的方式创建的字符串
会在编译器就放在字符串池中，常量池之前是放在方法区里面的，也就是在永久代里面的，从JDK7开始移到了堆里面。现在一般都用jdk7以上，所以在堆里。

下面从网上找了一些String判断是否相等的问题贴出来参考：

1. String str1 = "abc"; 
  System.out.println(str1 == "abc"); 

步骤： 
1) 栈中开辟一块空间存放引用str1， 
2) String池中开辟一块空间，存放String常量"abc"， 
3) 引用str1指向池中String常量"abc"， 
4) str1所指代的地址即常量"abc"所在地址，输出为true 

2. String str2 = new String("abc"); 
  System.out.println(str2 == "abc"); 

步骤： 
1) 栈中开辟一块空间存放引用str2， 
2) 堆中开辟一块空间存放一个新建的String对象"abc"， 
3) 引用str2指向堆中的新建的String对象"abc"， 
4) str2所指代的对象地址为堆中地址，而常量"abc"地址在池中，输出为false 

3. String str3 = new String（"abc"); 
  System.out.println(str3 == str2); 

步骤： 
1) 栈中开辟一块空间存放引用str3， 
2) 堆中开辟一块新空间存放另外一个(不同于str2所指)新建的String对象， 
3) 引用str3指向另外新建的那个String对象 
4) str3和str2指向堆中不同的String对象，地址也不相同，输出为false 

4. String str4 = "a" + "b"; 
  System.out.println(str4 == "ab"); 

步骤： 
1) 栈中开辟一块空间存放引用str4， 
2) 根据编译器合并已知量的优化功能，池中开辟一块空间，存放合并后的String常量"ab"， 
3) 引用str4指向池中常量"ab"， 
4) str4所指即池中常量"ab"，输出为true 

5. final String s = "a"; 
  String str5 = s + "b"; 
  System.out.println(str5 == "ab"); 

步骤： 
同4 

6. String s1 = "a"; 
  String s2 = "b"; 
  String str6 = s1 + s2; 
  System.out.println(str6 == "ab"); 

步骤： 
1) 栈中开辟一块中间存放引用s1，s1指向池中String常量"a"， 
2) 栈中开辟一块中间存放引用s2，s2指向池中String常量"b"， 
3) 栈中开辟一块中间存放引用str5， 
4) s1 + s2通过StringBuilder的最后一步toString()方法还原一个新的String对象"ab"，因此堆中开辟一块空间存放此对象， 
5) 引用str6指向堆中(s1 + s2)所还原的新String对象， 
6) str6指向的对象在堆中，而常量"ab"在池中，输出为false 

7. String str7 = "abc".substring(0, 2); 
  
步骤： 
1) 栈中开辟一块空间存放引用str7， 
2) substring()方法还原一个新的String对象"ab"（不同于str6所指），堆中开辟一块空间存放此对象， 
3) 引用str7指向堆中的新String对象， 

8. String str8 = "abc".toUpperCase(); 
  
步骤： 
1) 栈中开辟一块空间存放引用str6， 
2) toUpperCase()方法还原一个新的String对象"ABC"，池中并未开辟新的空间存放String常量"ABC"， 
3) 引用str8指向堆中的新String对象

非静态方法和静态方法的区别：
非静态方法有一个和静态方法很重大的不同：非静态方法有一个隐含的传入参数，该参数是JVM给它的，和我们怎么写代码无关，这个隐含的参数就是对象实例在Stack中的地址指针。因此非静态方法（在Stack中的指令代码）总是可以找到自己的专用数据（在Heap 中的对象属性值）。当然非静态方法也必须获得该隐含参数，因此非静态方法在调用前，必须先new一个对象实例，获得Stack中的地址指针，否则JVM将无法将隐含参数传给非静态方法。
静态方法无此隐含参数，因此也不需要new对象，只要class文件被ClassLoader load进入JVM的Stack，该静态方法即可被调用。当然此时静态方法是存取不到Heap 中的对象属性的。
总结一下该过程：当一个class文件被ClassLoader load进入JVM后，方法指令保存在Stack中，此时Heap 区没有数据。然后程序技术器开始执行指令，如果是静态方法，直接依次执行指令代码，当然此时指令代码是不能访问Heap 数据区的；如果是非静态方法，由于隐含参数没有值，会报错。因此在非静态方法执行前，要先new对象，在Heap 中分配数据，并把Stack中的地址指针交给非静态方法，这样程序技术器依次执行指令，而指令代码此时能够访问到Heap 数据区了。
静态属性和动态属性：
对象实例以及动态属性都是保存在Heap 中的，而Heap 必须通过Stack中的地址指针才能够被指令（类的方法）访问到。因此可以推断出：静态属性（static修饰的）是保存在Stack中的，而动态属性保存在Heap 中。正因为都是在Stack中，而Stack中指令和数据都是定长的，因此很容易算出偏移量，也因此不管什么指令（类的方法），都可以访问到类的静态属性。也正因为静态属性被保存在Stack中，所以具有了全局属性。因为没有Stack中的指针就无法访问heap中的数据区。

5)JVM ClassLoader机制

1、首先介绍下三个类加载器

bootstrap classloader --- 引导类加载器（原始类加载器），它负责加载Java的核心类。加载JVM需要的类。一旦调用java.exe程序，bootstrap类加载器就开始工作。因此，它必须使用native实现。另外，它还负责加载所有的Java核心类，例如java.lang，java.io等。【系统类】

extension classloader --- 扩展类加载器，负责加载JRE的拓展目录中JAR类包。只需把JAR文件拷贝到扩展目录下面即可，类加载器会自动的在下面查找

system classloader --- 系统类加载器（应用类加载器），加载应用程序。环境变量CLASSPATH目录下面查找相应的类

这几个类是父子关系，具体的继承关系如下图所示：

system classloader -> extension classloader -> bootstrap classloader

通过加载器将.class文件读入内存，组成我们使用的对象。类加载到内存中主要存放在以下2部分

A 在方法区，生成该类运行时的数据结构，如类信息（版本、字段，方法，接口等描述信息），常量，静态变量等；
B 在Java堆中，生成该类的java.lang.Class对象，一方面封装方法区中对应的信息，另一方面构建可被使用的Class类结构。

当然栈里面存放指令也是必不可少的，主要运行时，这里先主要阐述下加载。

2、获取引导类加载器加载了哪些类的方法如下：

URL[] urls=sun.misc.Launcher.getBootstrapClassPath().getURLs();
for (int i = 0; i < urls.length; i++) {
System.out.println(urls.toExternalForm());
}

3、获取应用类加载器： ClassLoader.getSystemClassLoader()

4、JVM类加载机制：全盘负责委托机制。 Java的ClassLoader采用全盘负责的委派机制。

全盘负责：当一个classloader加载一个Class的时候，这个Class所依赖的和引用的所有Class也由这个classloader负责载入，除非是显式的使用另外一个classloader载入；
委托机制：先让parent（父）类加载器(而不是super，它与parent classloader类不是继承关系)寻找，只有在parent找不到的时候才从自己的类路径中去寻找。每次都是由上到下地加载类。这样能保证每次都是先加载核心类，一层一层往外加载，再加上类重复加载的检查，能避免同名类引起的冲突。Bootstrap尝试加载此类，如果查找不到就会传给Extension，一直往下，直到成功加载此类，否者抛java.lang.ClassNotFoundException异常。 JDK的默认类加载器是System类加载器，每次加载时都会先调用System类加载器。但是他不会马上load，而是check该类是否存在，如果不存在就会交给父类来处理，直接传递给Bootstrap。

Cache机制：如果cache中保存了这个Class就直接返回它，如果没有才从文件中读取和转换成Class，并存入cache，这就是为什么我们修改了Class但是必须重新启动JVM才能生效的原因。

5）每个ClassLoader加载Class的过程是：
1.检测此Class是否载入过（即在cache中是否有此Class），如果有到8,如果没有到2
2.如果parent classloader不存在（没有parent，那parent一定是bootstrap classloader了），到4
3.请求parent classloader载入，如果成功到8，不成功到5
4.请求jvm从bootstrap classloader中载入，如果成功到8
5.寻找Class文件（从与此classloader相关的类路径中寻找）。如果找不到则到7.
6.从文件中载入Class，到8.
7.抛出ClassNotFoundException.
8.返回Class.
其中5.6步我们可以通过覆盖ClassLoader的findClass方法来实现自己的载入策略。甚至覆盖loadClass方法来实现自己的载入过程。

 
 5)、hashMap的原理 
 HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体。 

 
 结合了数据的查询快和链表的插入删除快的特性。 

 
 数组 
 的特点是：寻址容易，插入和删除困难；而 
 链表 
 的特点是：寻址困难，插入和删除容易。那么我们能不能综合两者的特性，做出一种寻址容易，插入删除也容易的数据结构？答案是肯定的，这就是我们要提起的 
 哈希表 
 ，哈希表有多种不同的实现方法，我接下来解释的是最常用的一种方法—— 拉链法，我们可以理解为“ 
 链表的数组 
 ” ，如图： 

 
 　　从上图我们可以发现哈希表是由数组+链表组成的，一个长度为16的数组中，每个元素存储的是一个链表的头结点。那么这些元素是按照什么样的规则存储到数组中呢。一般情况是通过hash(key)%len获得，也就是元素的key的哈希值对数组长度取模得到。比如上述哈希表中，12%16=12,28%16=12,108%16=12,140%16=12。所以12、28、108以及140都存储在数组下标为12的位置。 

 
 　　HashMap其实也是一个线性的数组实现的,所以可以理解为其存储数据的容器就是一个线性数组。这可能让我们很不解，一个线性的数组怎么实现按键值对来存取数据呢？这里HashMap有做一些处理。 

 
 　　1.首先HashMap里面实现一个静态内部类Entry，其重要的属性有 key , value, next，从属性key,value我们就能很明显的看出来Entry就是HashMap键值对实现的一个基础bean，我们上面说到HashMap的基础就是一个线性数组，这个数组就是Entry[]，Map里面的内容都保存在Entry[]里面。 

 
 HashMap的存取实现 

 
      既然是线性数组，为什么能随机存取？这里HashMap用了一个小算法，大致是这样实现： 

 
 //存储时: 
  
 int 
  hash = key.hashCode(); 
 // 这个hashCode方法这里不详述,只要理解每个key的hash是一个固定的int值 

 
 int 
  index = hash % Entry[].length;

 
 Entry[index] = value; 

 
 //取值时: 

 
 int 
  hash = key.hashCode();

 
 int 
  index = hash % Entry[].length; 

 
 return 
  Entry[index]; 

 
 如果两个key通过hash%Entry[].length得到的index相同，会不会有覆盖的危险？ 

 
 　　这里HashMap里面用到链式数据结构的一个概念。上面我们提到过Entry类里面有一个next属性，作用是指向下一个Entry。打个比方， 第一个键值对A进来，通过计算其key的hash得到的index=0，记做:Entry[0] = A。一会后又进来一个键值对B，通过计算其index也等于0，现在怎么办？HashMap会这样做:B.next = A,Entry[0] = B,如果又进来C,index也等于0,那么C.next = B,Entry[0] = C；这样我们发现index=0的地方其实存取了A,B,C三个键值对,他们通过next这个属性链接在一起。所以疑问不用担心。 
 也就是说数组中存储的是最后插入的元素。 
 到这里为止，HashMap的大致实现，我们应该已经清楚了。 

 
 　　当然HashMap里面也包含一些优化方面的实现，这里也说一下。比如：Entry[]的长度一定后，随着map里面数据的越来越长，这样同一个index的链就会很长，会不会影响性能？HashMap里面设置一个因素（也称为因子），随着map的size越来越大，Entry[]会以一定的规则加长长度。 

 
 解决hash冲突的办法 

开放定址法（线性探测再散列，二次探测再散列，伪随机探测再散列）
再哈希法
链地址法
建立一个公共溢出区

 
 Java中hashmap的解决办法就是采用的链地址法。也就是数据挂着链表 

 
 6、抽象类是否有构造函数 

有

 
 Abstract可以定义构造函数（包括带函数的构造函数），因为要保证其子类在创建的时候能够进行正确的初始化，但是Abstract类不能被实例化。子类在构造的时候先调用父类的构造函数。 

 
 7、类实例化过程 

 
       
 (静态变量、静态初始化块)>(变量、初始化快)>构造器（构造函数） 

 
 1 
 、 如果存在继承关系，就先父类后子类；  

 
 2  
 、如果在类内有静态变量和静态块，就先静态后非静态，最后才是构造函数；  

 
 3  
 、继承关系中，必须要父类初始化完成后，才初始化子类。 

 
  静态初始化块是：static初始化块是在构造函数之前执行的，而且只执行一次，即类首次加载时。 
  static {
         a = 5;
         System.out.println("Static init C.");
    } 
 
   初始化块： 
 
        {
         a = 5;
         System.out.println("Static init C.");
    } 
  测试代码：静态初始化代码只初始化一次

 
 8、文件索引方式 

1．索引文件

　索引文件由主文件和索引表构成。

　　①主文件：文件本身。

　　②索引表：在文件本身外建立的一张表，它指明逻辑记录和物理记录之间的一一对应关系。

2．索引表组成

　索引表由若干索引项组成。一般索引项由主关键字和该关键字所在记录的物理地址组成。

注意：

　索引表必须按主关键字有序，而主文件本身则可以按主关键字有序或无序。

3．索引顺序文件和索引非顺序文件

（1）索引顺序文件(Indexed Sequential File)

　主文件按主关键字有序的文件称索引顺序文件。

　在索引顺序文件中，可对一组记录建立一个索引项。这种索引表称为稀疏索引。

（2）索引非顺序文件(Indexed NonSequentail File)

　主文件按主关键字无序得文件称索引非顺序文件。

　在索引非顺序文件中，必须为每个记录建立一个索引项，这样建立的索引表称为稠密索引。

注意：

　① 通常将索引非顺序文件简称为索引文件。

　② 索引非顺序文件主文件无序，顺序存取将会频繁地引起磁头移动，适合于随机存取，不适合于顺序存取。

　③ 索引顺序文件的主文件是有序的，适合于随机存取、顺序存取。

　④ 索引顺序文件的索引是稀疏索引。索引占用空间较少，是最常用的一种文件组织。

　⑤ 最常用的索引顺序文件：ISAM文件和VSAM文件。

索引文件的存储

1．索引文件的存储

　索引文件在存储器上分为两个区：索引区和数据区。索引区存放索引表，数据区存放主文件。

 
 9、静态内部类、内部类作用 

 
 首先静态类不需要实例化即可访问其内部数据； 

 
 内部类可以对外界隐藏自己 
 ，而且又可以访问隐藏自己的外层类的数据。而静态内部类只能访问外部类的静态成员。 
 生成（new）一个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别Outer.Inner in=new Outer.Inner()； 
 只有将某个内部类修饰为静态类，然后才能够在这个类中定义静态的成员变量与成员方法。 

 
 （1）Java静态对象和非静态对象有什么区别？ 