数组的初始化动态初始化

数组的初始化分为两种！即为：静态初始化和动态初始化！简而言之，静态初始化就是，由程序员去指定显式（注意是显式）指定每个元素的值，系统自动判定数组长度。如下：int[] array = {1,2,3}; 动态初始化，则只需要指定长度，系统为元素自动分配初始值！int[] array=new int[3]; 这样就是动态初始化。那么这里就有些问题需要注意！1 不管是那种初始化方法，一旦初始化完成，数组长度不可改变。2 对于动态初始化方式，不同的数据类型，初始化的值则是不一样的。如是int类型，那么初始化的值则为 0，如果是引用数据类型如String,或者数组 ,那么就是null.在某些时候数组是不一定需要初始化的。如下： int[] array = {1,2,3}; int[] arr; arr = array; for(int i = 0 ; i < arr.length ; i ++){ System.out.println("arr["+i+"] = " + arr[i]); }

在明确list大小情况下应该尽可能的给定初始容量，节省内存开销。很多情况我们不知道初始容量，所以一般没有传入此参数，这样一来，其容量的扩充是基于2的多少次方来计算的，扩容的时候或许初始化了很多数组元素，但可能绝大部分没用到，这就浪费内存了。######回复 @PengTdy : 好像list如果不传入初始容量，默认初始容量是16，如果add了17个，那么容量变为32，add了33个变为64......，注意这里的16、 32、 64......。当然动态扩容的时候会重新分配list内部数组的内存空间，然后进行数据拷贝。如果程序员预先知道会add多少个，那么传入初始容量，就省去了扩容数组和数据拷贝，不管是内存分配和执行效率都会提升的。######回复 @BoXuan : 好的谢谢######回复 @PengTdy : 一般的数组是不能动态扩容的，list其实就是动态扩容数组，内部实现还是基于数组的。这个初始容量就是指示list内部数组初始化几个数组元素，你这里是2，就是初始化2个数组元素，而你这又刚好add了2个，你再add一下，内部数组扩容就会基于2的多少次方去重新初始化多少个数组元素，你可以找找ArrayList的源码看看######是不是 如果初始化值那里我设置的是3是不是就是3的次方,如果设置的6是不是就是6的次方;如果没有指定就是默认2的次方?######时刻想到，要节约使用内存空间。###### 图片里面圈出来的那个2是List初始大小.文档要求的那部分是String[] array = new String[list.size()],要求array的大小和list.size()一致.######回复 @PengTdy : 因为后来要把list里的数据(所有字符串元素)，都储存到字符串数组 array之中。试想一下，如果创建的字符串空间(array数组长度)太小，则不够存下 list 的所有元素；如果创建的字符串空间(array数组长度)太大，则没必要(太浪费)。故，一致才好。######这保持一致有什么好处吗?###### ArrayList 实现了接口 List<E>。所以，用 ArrayList 的构造方法所生成的对象， 可以用这个接口的名称 List<String>来表示其类型 。因为 List<E> 的泛型 E， 是字符串类型，所以在调用 ArrayList 的构造方法时，必须 指明它的元素是字符串类型：new ArrayList<String>(…);通过多态地挑选，选定的ArrayList 的构造方法是：public ArrayList(int initialCapacity)。调用这个函数的结果是，构造一个具有指定初始容量的空列表。其中参数：initialCapacity，表示列表的初始容量。在给出的代码里，initialCapacity 是 2。 “每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。”（出自： API 手册）从提供的代码可以看到，你提出的圆括号里的 2，表示要求产生的列表 list的初始容量是2个元素。接下来，果然添加了两个字符串元素: “guan”和 “bao”。看来，用来存储列表元素的数组的大小 2，正好够用。因此，list 的大小(list.size())仍然是 2。所以，最终导致创建并赋值的的字符串数组 array的长度，也是 2 。总之，你所提出的 （2 ）, 虽然只是 列表的初始容量。但 碰巧后来，只添加了2个字符串，致使，list 的大小未变，导致最终字符串数组的长度，也只是2。######回复 @PengTdy : 建议阅读 http://blog.csdn.net/arui319/article/details/3557743######如果初始化值那里我设置的是3是不是就是3的次方,如果设置的6是不是就是6的次方;如果没有指定就是默认2的次方?###### 大家的回复果然很溜。###### 预先分配容器的容量，1：可以节省内存使用；2：可以减少频繁扩容导致的内存垃圾和数组拷贝损耗。

class test{   private  $id; } 比如用查出的数组映射到一个private数组。 如果说你的熟悉是动态的话，那就要变通的方法，类里面是不能动态生成属性的。 初始化时构造函数里初始化，或者写个成员函数赋值。######属性是动态从数据库里读取出来的。######设置__get和__set()######magic method 里面自己写个 filter 限制一下能读取的“变量名”就行了

更实际的情况是，在程序运行开始时，程序已经具有一个初始的程序界面（初始界面可能只包含一个UIView），在程序运行过程中，程序需要根据用户交互来动态添加、删除UI控件。 在这种需求下，我们可以通过Interface Builder来设计程序的初始界面；接下来在程序运行过程中，可以通过代码创建UI控件，再将UI控件添加到相应的父控件中即可。 实例：动态添加、删除标签 首先创建一个iOS的Single View Application应用，创建完成后，该应用将自带一个Main.storyboard界面设计文件，但我们并不打算修改该界面设计文件，而是直接在程序代码中创建整个UI界面，程序只使用该界面文件中的UIView作为容器即可。 接下来修改控制器类，在控制器类的实现部分创建整个程序界面，绑定事件处理方法。下面是控制类的实现部分代码。 程序清单：codes/09/9.5/DynaLabel/DynaLabel/FKViewController.m #import "FKViewController.h" // 定义FKViewController的扩展 @interface FKViewController () // 定义一个属性来记录所有动态添加的UILabel控件 @property (nonatomic, strong) NSMutableArray* labels; @end @implementation FKViewController // 定义一个变量来记录下一个将要添加的UILabel的位置 int nextY = 80; - (void)viewDidLoad { [super viewDidLoad]; // 设置该view的背景色 self.view.backgroundColor = [UIColor grayColor]; // 初始化labels数组 self.labels = [NSMutableArray array]; // 创建UIButtonTypeRoundedRect类型的UIButton对象 UIButton* addBn = [UIButton buttonWithType:UIButtonTypeRoundedRect]; // 设置addBn的大小和位置 addBn.frame = CGRectMake(30, 30, 60, 40); // 为UIButton设置按钮文本 [addBn setTitle:@"添加" forState:UIControlStateNormal]; // 为addBn的Touch Up Inside事件绑定事件处理方法 [addBn addTarget:self action:@selector(add:) forControlEvents:UIControlEventTouchUpInside]; // 创建UIButtonTypeRoundedRect类型的UIButton对象 UIButton* removeBn = [UIButton buttonWithType:UIButtonTypeRoundedRect]; // 设置removeBn的大小和位置 removeBn.frame = CGRectMake(230, 30, 60, 40); // 为UIButton设置按钮文本 [removeBn setTitle:@"删除" forState:UIControlStateNormal]; // 为removeBn的Touch Up Inside事件绑定事件处理方法 [removeBn addTarget:self action:@selector(remove:) forControlEvents:UIControlEventTouchUpInside]; [self.view addSubview:addBn]; [self.view addSubview:removeBn]; } - (void)add:(id)sender { // 创建一个UILabel控件 UILabel* label = [[UILabel alloc] initWithFrame: CGRectMake(80, nextY, 160, 30)]; label.text = @"疯狂iOS讲义"; // 设置该UILabel显示的文本 [self.labels addObject: label]; // 将该UILabel添加到labels数组中 [self.view addSubview:label]; // 将UILabel控件添加到view父控件内 nextY += 50; // 控制nextY的值加50 } - (void)remove:(id)sender { // 如果labels数组中元素个数大于0，表明有UILabel可删除 if([self.labels count] > 0) { // 将最后一个UILabel从界面上删除 [[self.labels lastObject] removeFromSuperview]; [self.labels removeLastObject]; // 从labels数组中删除最后一个元素 nextY -= 50; // 控制nextY的值减50 } } @end 上面的代码中，第一段粗体字代码创建了应用的初始界面，该初始界面只包含两个按钮，并且程序还为这两个按钮绑定了事件处理方法。 提示： 上面程序中多次使用了CGRectMake()函数，该函数专门用于创建一个CGRect对象。当使用代码来创建UI控件时，总需要控制UI控件的大小和位置，通常都会用CGRect结构体，它代表一个矩形区的大小和位置。CGRect结构体包括origin、size两个成员，其中origin又是CGPoint类型的一个结构体，它包括x、y两个成员，代表该矩形区左上角的位置；size又是CGSize类型的一个结构体，它包括width、height两个成员，代表该矩形区的宽度和高度。正如CGRectMake()函数可返回一个CGRect结构体一样，CGPointMake(x,y)可返回一个CGPoint结构体，CGSizeMake(width，height)可返回一个CGSize对结构体。 该应用的关键就是实现add:和remove:两个方法，其中add:方法中粗体字代码负责创建一个UILabel控件（每次创建的UILabel的Y坐标并不相同），并将这个UILabel控件添加到该控制器关联的UIView内。这样即可实现每次用户触碰该按钮，程序界面就会添加一个UILabel控件；而remove:方法中粗体字代码则负责把labels数组的最后一个元素（UILabel控件）从父控件中删除，并从该数组中删除该元素。 通过上面的程序，即可实现通过用户交互来动态添加、删除程序界面控件。编译、运行该程序，并多次触碰添加、删除按钮后，可能看到如图9.37所示的动态界面。 ![Uploading screenshot . . .]()

每一个进程都有自己的内存虚拟地址空间,内存最小的单位是页(page).虚拟地址通过页表(Page Table)映射到物理内存,页表由操作系统维护并被CPU引用.Linux默认的栈(stack)大小为8MB.用户进程部分分段存储内容如下所示(从内存高地址到低地址):栈(stack): 函数参数、返回地址、局部变量等堆(heap): malloc(C)/new(C++)动态分配的内存BSS段(bss): 未初始化或初值为0的全局变量和静态局部变量数据段(data): 已初始化且初值非0的全局变量和静态局部变量代码段(text): 可执行代码、字符串字面值、只读变量详细解释:1.内核空间内核总是驻留在内存中，是操作系统的一部分。内核空间为内核保留，不允许应用程序读写该区域的内容或直接调用内核代码定义的函数。2.栈(stack)栈又称堆栈，由编译器自动分配释放，行为类似数据结构中的栈(先进后出)。堆栈主要有三个用途：(1)为函数内部声明的非静态局部变量(C语言中称“自动变量”)提供存储空间。(2)记录函数调用过程相关的维护性信息，称为栈帧(Stack Frame)或过程活动记录(Procedure Activation Record)。它包括函数返回地址，不适合装入寄存器的函数参数及一些寄存器值的保存。除递归调用外，堆栈并非必需。因为编译时可获知局部变量，参数和返回地址所需空间，并将其分配于BSS段。(3)临时存储区，用于暂存长算术表达式部分计算结果或alloca()函数分配的栈内内存。持续地重用栈空间有助于使活跃的栈内存保持在CPU缓存中，从而加速访问。进程中的每个线程都有属于自己的栈。向栈中不断压入数据时，若超出其容量就会耗尽栈对应的内存区域，从而触发一个页错误。此时若栈的大小低于堆栈最大值RLIMIT_STACK(Linux通常是8M)，则栈会动态增长，程序继续运行。映射的栈区扩展到所需大小后，不再收缩。Linux中ulimit -s命令可查看和设置堆栈最大值，当程序使用的堆栈超过该值时, 发生栈溢出(Stack Overflow)，程序收到一个段错误(Segmentation Fault)。注意，调高堆栈容量可能会增加内存开销和启动时间。堆栈既可向下增长(向内存低地址)也可向上增长, 这依赖于具体的实现。本文所述堆栈向下增长。堆栈的大小在运行时由内核动态调整。3.内存映射段(mmap)此处，内核将硬盘文件的内容直接映射到内存，任何应用程序都可通过Linux的mmap()系统调用或Windows的CreateFileMapping()/MapViewOfFile()请求这种映射。内存映射是一种方便高效的文件I/O方式，因而被用于装载动态共享库。用户也可创建匿名内存映射，该映射没有对应的文件，可用于存放程序数据。在Linux中，若通过malloc()请求一大块内存，C运行库将创建一个匿名内存映射，而不使用堆内存。“大块”意味着比阈值MMAP_THRESHOLD还大，缺省为128KB，可通过mallopt()调整。该区域用于映射可执行文件用到的动态链接库。在Linux 2.4内核中，若可执行文件依赖共享库，则系统会为这些动态库在从0x40000000开始的地址分配相应空间，并在程序装载时将其载入到该空间。在Linux 2.6内核中，共享库的起始地址被往上移动至更靠近栈区的位置。从进程地址空间的布局可以看到，在有共享库的情况下，留给堆的可用空间还有两处：一处是从BSS段到0x40000000，约不到1GB的空间；另一处是从共享库到栈之间的空间，约不到2GB。这两块空间大小取决于栈、共享库的大小和数量。这样来看，是否应用程序可申请的最大堆空间只有2GB？事实上，这与Linux内核版本有关。在上面给出的进程地址空间经典布局图中，共享库的装载地址为0x40000000，这实际上是Linux kernel 2.6版本之前的情况了，在2.6版本里，共享库的装载地址已经被挪到靠近栈的位置，即位于0xBFxxxxxx附近，因此，此时的堆范围就不会被共享库分割成2个“碎片”，故kernel 2.6的32位Linux系统中，malloc申请的最大内存理论值在2.9GB左右。4.堆(heap)堆用于存放进程运行时动态分配的内存段，可动态扩张或缩减。堆中内容是匿名的，不能按名字直接访问，只能通过指针间接访问。当进程调用malloc(C)/new(C++)等函数分配内存时，新分配的内存动态添加到堆上(扩张)；当调用free(C)/delete(C++)等函数释放内存时，被释放的内存从堆中剔除(缩减) 。分配的堆内存是经过字节对齐的空间，以适合原子操作。堆管理器通过链表管理每个申请的内存，由于堆申请和释放是无序的，最终会产生内存碎片。堆内存一般由应用程序分配释放，回收的内存可供重新使用。若程序员不释放，程序结束时操作系统可能会自动回收。堆的末端由break指针标识，当堆管理器需要更多内存时，可通过系统调用brk()和sbrk()来移动break指针以扩张堆，一般由系统自动调用。使用堆时经常出现两种问题：(1) 释放或改写仍在使用的内存(“内存破坏”)；(2) 未释放不再使用的内存(“内存泄漏”)。当释放次数少于申请次数时，可能已造成内存泄漏。泄漏的内存往往比忘记释放的数据结构更大，因为所分配的内存通常会圆整为下个大于申请数量的2的幂次(如申请212B，会圆整为256B)。注意，堆不同于数据结构中的”堆”，其行为类似链表。5.BSS段BSS(Block Started by Symbol)段中通常存放程序中以下符号：未初始化的全局变量和静态局部变量.初始值为0的全局变量和静态局部变量(依赖于编译器实现).未定义且初值不为0的符号(该初值即common block的大小).C语言中，未显式初始化的静态分配变量被初始化为0(算术类型)或空指针(指针类型)。由于程序加载时，BSS会被操作系统清零，所以未赋初值或初值为0的全局变量都在BSS中。BSS段仅为未初始化的静态分配变量预留位置，在目标文件中并不占据空间，这样可减少目标文件体积。但程序运行时需为变量分配内存空间，故目标文件必须记录所有未初始化的静态分配变量大小总和(通过start_bss和end_bss地址写入机器代码)。当加载器(loader)加载程序时，将为BSS段分配的内存初始化为0。在嵌入式软件中，进入main()函数之前BSS段被C运行时系统映射到初始化为全零的内存(效率较高)。注意，尽管均放置于BSS段，但初值为0的全局变量是强符号，而未初始化的全局变量是弱符号。若其他地方已定义同名的强符号(初值可能非0)，则弱符号与之链接时不会引起重定义错误，但运行时的初值可能并非期望值(会被强符号覆盖)。因此，定义全局变量时，若只有本文件使用，则尽量使用static关键字修饰；否则需要为全局变量定义赋初值(哪怕0值)，保证该变量为强符号，以便链接时发现变量名冲突，而不是被未知值覆盖。某些编译器将未初始化的全局变量保存在common段，链接时再将其放入BSS段。在编译阶段可通过-fno-common选项来禁止将未初始化的全局变量放入common段。此外，由于目标文件不含BSS段，故程序烧入存储器(Flash)后BSS段地址空间内容未知。U-Boot(一个嵌入式操作系统引导程序)启动过程中，将U-Boot的Stage2代码(通常位于lib_xxxx/board.c文件)搬迁(拷贝)到SDRAM空间后必须人为添加清零BSS段的代码，而不可依赖于Stage2代码中变量定义时赋0值。BSS段不包含数据，仅维护开始和结束地址，以便内存能在运行时被有效地清零。BSS所需的运行时空间由目标文件记录，但BSS并不占用目标文件内的实际空间，即BSS节段应用程序的二进制映象文件中并不存在。6.数据段(data)数据段通常用于存放程序中已初始化且初值不为0的全局变量和静态局部变量。数据段属于静态内存分配(静态存储区)，可读可写。数据段保存在目标文件中(在嵌入式系统里一般固化在镜像文件中)，其内容由程序初始化。例如，对于全局变量int gVar = 10，必须在目标文件数据段中保存10这个数据，然后在程序加载时复制到相应的内存。数据段与BSS段的区别如下： (1) BSS段不占用物理文件尺寸，但占用内存空间；数据段占用物理文件，也占用内存空间。对于大型数组如int ar0[10000] = {1, 2, 3, ...}和int ar1[10000]，ar1放在BSS段，只记录共有10000*4个字节需要初始化为0，而不是像ar0那样记录每个数据1、2、3...，此时BSS为目标文件所节省的磁盘空间相当可观。(2) 当程序读取数据段的数据时，系统会发出缺页故障，从而分配相应的物理内存；当程序读取BSS段的数据时，内核会将其转到一个全零页面，不会发生缺页故障，也不会为其分配相应的物理内存。运行时数据段和BSS段的整个区段通常称为数据区。某些资料中“数据段”指代数据段 + BSS段 + 堆。7.代码段(text)代码段也称正文段或文本段，通常用于存放程序执行代码(即CPU执行的机器指令)。一般C语言执行语句都编译成机器代码保存在代码段。通常代码段是可共享的，因此频繁执行的程序只需要在内存中拥有一份拷贝即可。代码段通常属于只读，以防止其他程序意外地修改其指令(对该段的写操作将导致段错误)。某些架构也允许代码段为可写，即允许修改程序。代码段指令根据程序设计流程依次执行，对于顺序指令，只会执行一次(每个进程)；若有反复，则需使用跳转指令；若进行递归，则需要借助栈来实现。代码段指令中包括操作码和操作对象(或对象地址引用)。若操作对象是立即数(具体数值)，将直接包含在代码中；若是局部数据，将在栈区分配空间，然后引用该数据地址；若位于BSS段和数据段，同样引用该数据地址。代码段最容易受优化措施影响。8.保留区(reservd)位于虚拟地址空间的最低部分，未赋予物理地址。任何对它的引用都是非法的，用于捕捉使用空指针和小整型值指针引用内存的异常情况。它并不是一个单一的内存区域，而是对地址空间中受到操作系统保护而禁止用户进程访问的地址区域的总称。大多数操作系统中，极小的地址通常都是不允许访问的，如NULL。C语言将无效指针赋值为0也是出于这种考虑，因为0地址上正常情况下不会存放有效的可访问数据。在32位x86架构的Linux系统中，用户进程可执行程序一般从虚拟地址空间0x08048000开始加载。该加载地址由ELF文件头决定，可通过自定义链接器脚本覆盖链接器默认配置，进而修改加载地址。0x08048000以下的地址空间通常由C动态链接库、动态加载器ld.so和内核VDSO(内核提供的虚拟共享库)等占用。通过使用mmap系统调用，可访问0x08048000以下的地址空间。

new应避免将C ++数组与（即使用动态数组）一起使用。有一个问题，您必须跟踪大小，并且需要手动删除它们，并进行各种整理。 不建议在堆栈上使用数组，因为您没有进行范围检查，并且将数组传递给周围将丢失任何有关其大小的信息（数组到指针转换）。boost::array在这种情况下，应使用将C ++数组包装在一个小类中，并提供一个size函数和迭代器对其进行迭代的情况。 现在，将std :: vector与本机C ++数组（从互联网上获取）： // Comparison of assembly code generated for basic indexing, dereferencing, // and increment operations on vectors and arrays/pointers. // Assembly code was generated by gcc 4.1.0 invoked with g++ -O3 -S on a // x86_64-suse-linux machine. #include struct S { int padding; std::vector v; int * p; std::vector ::iterator i; }; int pointer_index (S & s) { return s.p[3]; } // movq 32(%rdi), %rax // movl 12(%rax), %eax // ret int vector_index (S & s) { return s.v[3]; } // movq 8(%rdi), %rax // movl 12(%rax), %eax // ret // Conclusion: Indexing a vector is the same damn thing as indexing a pointer. int pointer_deref (S & s) { return *s.p; } // movq 32(%rdi), %rax // movl (%rax), %eax // ret int iterator_deref (S & s) { return *s.i; } // movq 40(%rdi), %rax // movl (%rax), %eax // ret // Conclusion: Dereferencing a vector iterator is the same damn thing // as dereferencing a pointer. void pointer_increment (S & s) { ++s.p; } // addq $4, 32(%rdi) // ret void iterator_increment (S & s) { ++s.i; } // addq $4, 40(%rdi) // ret // Conclusion: Incrementing a vector iterator is the same damn thing as // incrementing a pointer. 注意：如果使用分配数组new并分配非类对象（例如plain int）或不使用用户定义的构造函数的类，并且您不想初始初始化元素，则使用new-allocated数组可能会带来性能优势，因为std::vector将所有元素初始化为构造上的默认值（例如，对于int来说是0） 问题来源于stack overflow

MySQL中主要有三种类型的变量： 用户定义的变量（以开头@）： 您可以访问任何用户定义的变量，而无需对其进行声明或初始化。如果引用的变量尚未初始化，则其值为NULL和字符串类型。 SELECT @var_any_var_name 您可以使用SET或SELECT语句来初始化变量： SET @start = 1, @finish = 10; 要么 SELECT @start := 1, @finish := 10; SELECT * FROM places WHERE place BETWEEN @start AND @finish; 可以从一组有限的数据类型中为用户变量分配一个值：整数，十进制，浮点数，二进制或非二进制字符串或NULL值。 用户定义的变量是特定于会话的。即，一个客户端定义的用户变量不能被其他客户端看到或使用。 可以SELECT使用高级MySQL用户变量技术在查询中使用它们。 局部变量（无前缀）： 局部变量需要在使用DECLARE之前声明。 它们可用作存储过程内的局部变量和输入参数： DELIMITER // CREATE PROCEDURE sp_test(var1 INT) BEGIN DECLARE start INT unsigned DEFAULT 1; DECLARE finish INT unsigned DEFAULT 10; SELECT var1, start, finish; SELECT * FROM places WHERE place BETWEEN start AND finish; END; // DELIMITER ; CALL sp_test(5); 如果DEFAULT缺少该子句，则初始值为NULL。 局部变量的范围是BEGIN ... END在其内声明的块。 服务器系统变量（以前缀@@）： MySQL服务器维护许多配置为默认值的系统变量。它们可以是类型GLOBAL，SESSION或BOTH。 全局变量影响服务器的整体操作，而会话变量影响单个客户端连接的服务器操作。 要查看正在运行的服务器使用的当前值，请使用SHOW VARIABLES语句或SELECT @@var_name。 SHOW VARIABLES LIKE '%wait_timeout%'; SELECT @@sort_buffer_size; 可以在服务器启动时使用命令行或选项文件中的选项来设置它们。其中的大多数可以在服务器运行时使用SET GLOBAL或动态更改SET SESSION： -- Syntax to Set value to a Global variable: SET GLOBAL sort_buffer_size=1000000; SET @@global.sort_buffer_size=1000000; -- Syntax to Set value to a Session variable: SET sort_buffer_size=1000000; SET SESSION sort_buffer_size=1000000; SET @@sort_buffer_size=1000000; SET @@local.sort_buffer_size=10000;来源：stack overflow

遍历一个 List 有哪些不同的方式？每种方法的实现原理是什么？Java 中 List 遍历的最佳实践是什么？ 遍历方式有以下几种： for 循环遍历，基于计数器。在集合外部维护一个计数器，然后依次读取每一个位置的元素，当读取到最后一个元素后停止。 迭代器遍历，Iterator。Iterator 是面向对象的一个设计模式，目的是屏蔽不同数据集合的特点，统一遍历集合的接口。Java 在 Collections 中支持了 Iterator 模式。 foreach 循环遍历。foreach 内部也是采用了 Iterator 的方式实现，使用时不需要显式声明 Iterator 或计数器。优点是代码简洁，不易出错；缺点是只能做简单的遍历，不能在遍历过程中操作数据集合，例如删除、替换。 最佳实践：Java Collections 框架中提供了一个 RandomAccess 接口，用来标记 List 实现是否支持 Random Access。 如果一个数据集合实现了该接口，就意味着它支持 Random Access，按位置读取元素的平均时间复杂度为 O(1)，如ArrayList。如果没有实现该接口，表示不支持 Random Access，如LinkedList。 推荐的做法就是，支持 Random Access 的列表可用 for 循环遍历，否则建议用 Iterator 或 foreach 遍历。 说一下 ArrayList 的优缺点 ArrayList的优点如下： ArrayList 底层以数组实现，是一种随机访问模式。ArrayList 实现了 RandomAccess 接口，因此查找的时候非常快。ArrayList 在顺序添加一个元素的时候非常方便。 ArrayList 的缺点如下： 删除元素的时候，需要做一次元素复制操作。如果要复制的元素很多，那么就会比较耗费性能。插入元素的时候，也需要做一次元素复制操作，缺点同上。 ArrayList 比较适合顺序添加、随机访问的场景。 如何实现数组和 List 之间的转换？ 数组转 List：使用 Arrays. asList(array) 进行转换。List 转数组：使用 List 自带的 toArray() 方法。 代码示例： ArrayList 和 LinkedList 的区别是什么？ 数据结构实现：ArrayList 是动态数组的数据结构实现，而 LinkedList 是双向链表的数据结构实现。随机访问效率：ArrayList 比 LinkedList 在随机访问的时候效率要高，因为 LinkedList 是线性的数据存储方式，所以需要移动指针从前往后依次查找。增加和删除效率：在非首尾的增加和删除操作，LinkedList 要比 ArrayList 效率要高，因为 ArrayList 增删操作要影响数组内的其他数据的下标。内存空间占用：LinkedList 比 ArrayList 更占内存，因为 LinkedList 的节点除了存储数据，还存储了两个引用，一个指向前一个元素，一个指向后一个元素。线程安全：ArrayList 和 LinkedList 都是不同步的，也就是不保证线程安全； 综合来说，在需要频繁读取集合中的元素时，更推荐使用 ArrayList，而在插入和删除操作较多时，更推荐使用 LinkedList。 补充：数据结构基础之双向链表 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。 ArrayList 和 Vector 的区别是什么？ 这两个类都实现了 List 接口（List 接口继承了 Collection 接口），他们都是有序集合 线程安全：Vector 使用了 Synchronized 来实现线程同步，是线程安全的，而 ArrayList 是非线程安全的。性能：ArrayList 在性能方面要优于 Vector。扩容：ArrayList 和 Vector 都会根据实际的需要动态的调整容量，只不过在 Vector 扩容每次会增加 1 倍，而 ArrayList 只会增加 50%。 Vector类的所有方法都是同步的。可以由两个线程安全地访问一个Vector对象、但是一个线程访问Vector的话代码要在同步操作上耗费大量的时间。 Arraylist不是同步的，所以在不需要保证线程安全时时建议使用Arraylist。 插入数据时，ArrayList、LinkedList、Vector谁速度较快？阐述 ArrayList、Vector、LinkedList 的存储性能和特性？ ArrayList、LinkedList、Vector 底层的实现都是使用数组方式存储数据。数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢。 Vector 中的方法由于加了 synchronized 修饰，因此 Vector 是线程安全容器，但性能上较ArrayList差。 LinkedList 使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但插入数据时只需要记录当前项的前后项即可，所以 LinkedList 插入速度较快。 多线程场景下如何使用 ArrayList？ ArrayList 不是线程安全的，如果遇到多线程场景，可以通过 Collections 的 synchronizedList 方法将其转换成线程安全的容器后再使用。例如像下面这样： 为什么 ArrayList 的 elementData 加上 transient 修饰？ ArrayList 中的数组定义如下： private transient Object[] elementData; 再看一下 ArrayList 的定义： public class ArrayList extends AbstractList implements List<E>, RandomAccess, Cloneable, java.io.Serializable 可以看到 ArrayList 实现了 Serializable 接口，这意味着 ArrayList 支持序列化。transient 的作用是说不希望 elementData 数组被序列化，重写了 writeObject 实现： 每次序列化时，先调用 defaultWriteObject() 方法序列化 ArrayList 中的非 transient 元素，然后遍历 elementData，只序列化已存入的元素，这样既加快了序列化的速度，又减小了序列化之后的文件大小。 List 和 Set 的区别 List , Set 都是继承自Collection 接口 List 特点：一个有序（元素存入集合的顺序和取出的顺序一致）容器，元素可以重复，可以插入多个null元素，元素都有索引。常用的实现类有 ArrayList、LinkedList 和 Vector。 Set 特点：一个无序（存入和取出顺序有可能不一致）容器，不可以存储重复元素，只允许存入一个null元素，必须保证元素唯一性。Set 接口常用实现类是 HashSet、LinkedHashSet 以及 TreeSet。 另外 List 支持for循环，也就是通过下标来遍历，也可以用迭代器，但是set只能用迭代，因为他无序，无法用下标来取得想要的值。 Set和List对比 Set：检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变。 List：和数组类似，List可以动态增长，查找元素效率高，插入删除元素效率低，因为会引起其他元素位置改变 Set接口 说一下 HashSet 的实现原理？ HashSet 是基于 HashMap 实现的，HashSet的值存放于HashMap的key上，HashMap的value统一为PRESENT，因此 HashSet 的实现比较简单，相关 HashSet 的操作，基本上都是直接调用底层 HashMap 的相关方法来完成，HashSet 不允许重复的值。 HashSet如何检查重复？HashSet是如何保证数据不可重复的？ 向HashSet 中add ()元素时，判断元素是否存在的依据，不仅要比较hash值，同时还要结合equles 方法比较。 HashSet 中的add ()方法会使用HashMap 的put()方法。 HashMap 的 key 是唯一的，由源码可以看出 HashSet 添加进去的值就是作为HashMap 的key，并且在HashMap中如果K/V相同时，会用新的V覆盖掉旧的V，然后返回旧的V。所以不会重复（ HashMap 比较key是否相等是先比较hashcode 再比较equals ）。 以下是HashSet 部分源码： hashCode（）与equals（）的相关规定： 如果两个对象相等，则hashcode一定也是相同的 两个对象相等,对两个equals方法返回true 两个对象有相同的hashcode值，它们也不一定是相等的 综上，equals方法被覆盖过，则hashCode方法也必须被覆盖 hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写hashCode()，则该class的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）。 ** ==与equals的区别** ==是判断两个变量或实例是不是指向同一个内存空间 equals是判断两个变量或实例所指向的内存空间的值是不是相同 ==是指对内存地址进行比较 equals()是对字符串的内容进行比较3.==指引用是否相同 equals()指的是值是否相同 HashSet与HashMap的区别 Queue BlockingQueue是什么？ Java.util.concurrent.BlockingQueue是一个队列，在进行检索或移除一个元素的时候，它会等待队列变为非空；当在添加一个元素时，它会等待队列中的可用空间。BlockingQueue接口是Java集合框架的一部分，主要用于实现生产者-消费者模式。我们不需要担心等待生产者有可用的空间，或消费者有可用的对象，因为它都在BlockingQueue的实现类中被处理了。Java提供了集中BlockingQueue的实现，比如ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue,、SynchronousQueue等。 在 Queue 中 poll()和 remove()有什么区别？ 相同点：都是返回第一个元素，并在队列中删除返回的对象。 不同点：如果没有元素 poll()会返回 null，而 remove()会直接抛出 NoSuchElementException 异常。 代码示例： Queue queue = new LinkedList (); queue. offer("string"); // add System. out. println(queue. poll()); System. out. println(queue. remove()); System. out. println(queue. size()); Map接口 说一下 HashMap 的实现原理？ HashMap概述： HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。 HashMap的数据结构： 在Java编程语言中，最基本的结构就是两种，一个是数组，另外一个是模拟指针（引用），所有的数据结构都可以用这两个基本结构来构造的，HashMap也不例外。HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体。 HashMap 基于 Hash 算法实现的 当我们往Hashmap中put元素时，利用key的hashCode重新hash计算出当前对象的元素在数组中的下标存储时，如果出现hash值相同的key，此时有两种情况。(1)如果key相同，则覆盖原始值；(2)如果key不同（出现冲突），则将当前的key-value放入链表中获取时，直接找到hash值对应的下标，在进一步判断key是否相同，从而找到对应值。理解了以上过程就不难明白HashMap是如何解决hash冲突的问题，核心就是使用了数组的存储方式，然后将冲突的key的对象放入链表中，一旦发现冲突就在链表中做进一步的对比。 需要注意Jdk 1.8中对HashMap的实现做了优化，当链表中的节点数据超过八个之后，该链表会转为红黑树来提高查询效率，从原来的O(n)到O(logn) HashMap在JDK1.7和JDK1.8中有哪些不同？HashMap的底层实现 在Java中，保存数据有两种比较简单的数据结构：数组和链表。数组的特点是：寻址容易，插入和删除困难；链表的特点是：寻址困难，但插入和删除容易；所以我们将数组和链表结合在一起，发挥两者各自的优势，使用一种叫做拉链法的方式可以解决哈希冲突。 JDK1.8之前 JDK1.8之前采用的是拉链法。拉链法：将链表和数组相结合。也就是说创建一个链表数组，数组中每一格就是一个链表。若遇到哈希冲突，则将冲突的值加到链表中即可。 JDK1.8之后 相比于之前的版本，jdk1.8在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间。 JDK1.7 VS JDK1.8 比较 JDK1.8主要解决或优化了一下问题： resize 扩容优化引入了红黑树，目的是避免单条链表过长而影响查询效率，红黑树算法请参考解决了多线程死循环问题，但仍是非线程安全的，多线程时可能会造成数据丢失问题。 HashMap的put方法的具体流程？ 当我们put的时候，首先计算 key的hash值，这里调用了 hash方法，hash方法实际是让key.hashCode()与key.hashCode()>>>16进行异或操作，高16bit补0，一个数和0异或不变，所以 hash 函数大概的作用就是：高16bit不变，低16bit和高16bit做了一个异或，目的是减少碰撞。按照函数注释，因为bucket数组大小是2的幂，计算下标index = (table.length - 1) & hash，如果不做 hash 处理，相当于散列生效的只有几个低 bit 位，为了减少散列的碰撞，设计者综合考虑了速度、作用、质量之后，使用高16bit和低16bit异或来简单处理减少碰撞，而且JDK8中用了复杂度 O（logn）的树结构来提升碰撞下的性能。 putVal方法执行流程图 ①.判断键值对数组table[i]是否为空或为null，否则执行resize()进行扩容； ②.根据键值key计算hash值得到插入的数组索引i，如果table[i]==null，直接新建节点添加，转向⑥，如果table[i]不为空，转向③； ③.判断table[i]的首个元素是否和key一样，如果相同直接覆盖value，否则转向④，这里的相同指的是hashCode以及equals； ④.判断table[i] 是否为treeNode，即table[i] 是否是红黑树，如果是红黑树，则直接在树中插入键值对，否则转向⑤； ⑤.遍历table[i]，判断链表长度是否大于8，大于8的话把链表转换为红黑树，在红黑树中执行插入操作，否则进行链表的插入操作；遍历过程中若发现key已经存在直接覆盖value即可； ⑥.插入成功后，判断实际存在的键值对数量size是否超多了最大容量threshold，如果超过，进行扩容。 HashMap的扩容操作是怎么实现的？ ①.在jdk1.8中，resize方法是在hashmap中的键值对大于阀值时或者初始化时，就调用resize方法进行扩容； ②.每次扩展的时候，都是扩展2倍； ③.扩展后Node对象的位置要么在原位置，要么移动到原偏移量两倍的位置。 在putVal()中，我们看到在这个函数里面使用到了2次resize()方法，resize()方法表示的在进行第一次初始化时会对其进行扩容，或者当该数组的实际大小大于其临界值值(第一次为12),这个时候在扩容的同时也会伴随的桶上面的元素进行重新分发，这也是JDK1.8版本的一个优化的地方，在1.7中，扩容之后需要重新去计算其Hash值，根据Hash值对其进行分发，但在1.8版本中，则是根据在同一个桶的位置中进行判断(e.hash & oldCap)是否为0，重新进行hash分配后，该元素的位置要么停留在原始位置，要么移动到原始位置+增加的数组大小这个位置上 HashMap是怎么解决哈希冲突的？ 答：在解决这个问题之前，我们首先需要知道什么是哈希冲突，而在了解哈希冲突之前我们还要知道什么是哈希才行； 什么是哈希？ Hash，一般翻译为“散列”，也有直接音译为“哈希”的，这就是把任意长度的输入通过散列算法，变换成固定长度的输出，该输出就是散列值（哈希值）；这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。 所有散列函数都有如下一个基本特性**：根据同一散列函数计算出的散列值如果不同，那么输入值肯定也不同。但是，根据同一散列函数计算出的散列值如果相同，输入值不一定相同**。 什么是哈希冲突？ 当两个不同的输入值，根据同一散列函数计算出相同的散列值的现象，我们就把它叫做碰撞（哈希碰撞）。 HashMap的数据结构 在Java中，保存数据有两种比较简单的数据结构：数组和链表。数组的特点是：寻址容易，插入和删除困难；链表的特点是：寻址困难，但插入和删除容易；所以我们将数组和链表结合在一起，发挥两者各自的优势，使用一种叫做链地址法的方式可以解决哈希冲突： 这样我们就可以将拥有相同哈希值的对象组织成一个链表放在hash值所对应的bucket下，但相比于hashCode返回的int类型，我们HashMap初始的容量大小DEFAULT_INITIAL_CAPACITY = 1 << 4（即2的四次方16）要远小于int类型的范围，所以我们如果只是单纯的用hashCode取余来获取对应的bucket这将会大大增加哈希碰撞的概率，并且最坏情况下还会将HashMap变成一个单链表，所以我们还需要对hashCode作一定的优化 hash()函数 上面提到的问题，主要是因为如果使用hashCode取余，那么相当于参与运算的只有hashCode的低位，高位是没有起到任何作用的，所以我们的思路就是让hashCode取值出的高位也参与运算，进一步降低hash碰撞的概率，使得数据分布更平均，我们把这样的操作称为扰动，在JDK 1.8中的hash()函数如下： static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);// 与自己右移16位进行异或运算（高低位异或） } 这比在JDK 1.7中，更为简洁，相比在1.7中的4次位运算，5次异或运算（9次扰动），在1.8中，只进行了1次位运算和1次异或运算（2次扰动）； JDK1.8新增红黑树 通过上面的链地址法（使用散列表）和扰动函数我们成功让我们的数据分布更平均，哈希碰撞减少，但是当我们的HashMap中存在大量数据时，加入我们某个bucket下对应的链表有n个元素，那么遍历时间复杂度就为O(n)，为了针对这个问题，JDK1.8在HashMap中新增了红黑树的数据结构，进一步使得遍历复杂度降低至O(logn)； 总结 简单总结一下HashMap是使用了哪些方法来有效解决哈希冲突的： 使用链地址法（使用散列表）来链接拥有相同hash值的数据；使用2次扰动函数（hash函数）来降低哈希冲突的概率，使得数据分布更平均；引入红黑树进一步降低遍历的时间复杂度，使得遍历更快； **能否使用任何类作为 Map 的 key？ **可以使用任何类作为 Map 的 key，然而在使用之前，需要考虑以下几点： 如果类重写了 equals() 方法，也应该重写 hashCode() 方法。 类的所有实例需要遵循与 equals() 和 hashCode() 相关的规则。 如果一个类没有使用 equals()，不应该在 hashCode() 中使用它。 用户自定义 Key 类最佳实践是使之为不可变的，这样 hashCode() 值可以被缓存起来，拥有更好的性能。不可变的类也可以确保 hashCode() 和 equals() 在未来不会改变，这样就会解决与可变相关的问题了。 为什么HashMap中String、Integer这样的包装类适合作为K？ 答：String、Integer等包装类的特性能够保证Hash值的不可更改性和计算准确性，能够有效的减少Hash碰撞的几率 都是final类型，即不可变性，保证key的不可更改性，不会存在获取hash值不同的情况 内部已重写了equals()、hashCode()等方法，遵守了HashMap内部的规范（不清楚可以去上面看看putValue的过程），不容易出现Hash值计算错误的情况； 如果使用Object作为HashMap的Key，应该怎么办呢？ 答：重写hashCode()和equals()方法 重写hashCode()是因为需要计算存储数据的存储位置，需要注意不要试图从散列码计算中排除掉一个对象的关键部分来提高性能，这样虽然能更快但可能会导致更多的Hash碰撞； 重写equals()方法，需要遵守自反性、对称性、传递性、一致性以及对于任何非null的引用值x，x.equals(null)必须返回false的这几个特性，目的是为了保证key在哈希表中的唯一性； HashMap为什么不直接使用hashCode()处理后的哈希值直接作为table的下标 答：hashCode()方法返回的是int整数类型，其范围为-(2 ^ 31)~(2 ^ 31 - 1)，约有40亿个映射空间，而HashMap的容量范围是在16（初始化默认值）~2 ^ 30，HashMap通常情况下是取不到最大值的，并且设备上也难以提供这么多的存储空间，从而导致通过hashCode()计算出的哈希值可能不在数组大小范围内，进而无法匹配存储位置； 那怎么解决呢？ HashMap自己实现了自己的hash()方法，通过两次扰动使得它自己的哈希值高低位自行进行异或运算，降低哈希碰撞概率也使得数据分布更平均； 在保证数组长度为2的幂次方的时候，使用hash()运算之后的值与运算（&）（数组长度 - 1）来获取数组下标的方式进行存储，这样一来是比取余操作更加有效率，二来也是因为只有当数组长度为2的幂次方时，h&(length-1)才等价于h%length，三来解决了“哈希值与数组大小范围不匹配”的问题； HashMap 的长度为什么是2的幂次方 为了能让 HashMap 存取高效，尽量较少碰撞，也就是要尽量把数据分配均匀，每个链表/红黑树长度大致相同。这个实现就是把数据存到哪个链表/红黑树中的算法。 这个算法应该如何设计呢？ 我们首先可能会想到采用%取余的操作来实现。但是，重点来了：“取余(%)操作中如果除数是2的幂次则等价于与其除数减一的与(&)操作（也就是说 hash%length==hash&(length-1)的前提是 length 是2的 n 次方；）。” 并且 采用二进制位操作 &，相对于%能够提高运算效率，这就解释了 HashMap 的长度为什么是2的幂次方。 那为什么是两次扰动呢？ 答：这样就是加大哈希值低位的随机性，使得分布更均匀，从而提高对应数组存储下标位置的随机性&均匀性，最终减少Hash冲突，两次就够了，已经达到了高位低位同时参与运算的目的； HashMap 与 HashTable 有什么区别？ 线程安全： HashMap 是非线程安全的，HashTable 是线程安全的；HashTable 内部的方法基本都经过 synchronized 修饰。（如果你要保证线程安全的话就使用 ConcurrentHashMap 吧！）； 效率： 因为线程安全的问题，HashMap 要比 HashTable 效率高一点。另外，HashTable 基本被淘汰，不要在代码中使用它； 对Null key 和Null value的支持： HashMap 中，null 可以作为键，这样的键只有一个，可以有一个或多个键所对应的值为 null。但是在 HashTable 中 put 进的键值只要有一个 null，直接抛NullPointerException。 **初始容量大小和每次扩充容量大小的不同 **： ①创建时如果不指定容量初始值，Hashtable 默认的初始大小为11，之后每次扩充，容量变为原来的2n+1。HashMap 默认的初始化大小为16。之后每次扩充，容量变为原来的2倍。②创建时如果给定了容量初始值，那么 Hashtable 会直接使用你给定的大小，而 HashMap 会将其扩充为2的幂次方大小。也就是说 HashMap 总是使用2的幂作为哈希表的大小，后面会介绍到为什么是2的幂次方。 底层数据结构： JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间。Hashtable 没有这样的机制。 推荐使用：在 Hashtable 的类注释可以看到，Hashtable 是保留类不建议使用，推荐在单线程环境下使用 HashMap 替代，如果需要多线程使用则用 ConcurrentHashMap 替代。 如何决定使用 HashMap 还是 TreeMap？ 对于在Map中插入、删除和定位元素这类操作，HashMap是最好的选择。然而，假如你需要对一个有序的key集合进行遍历，TreeMap是更好的选择。基于你的collection的大小，也许向HashMap中添加元素会更快，将map换为TreeMap进行有序key的遍历。 HashMap 和 ConcurrentHashMap 的区别 ConcurrentHashMap对整个桶数组进行了分割分段(Segment)，然后在每一个分段上都用lock锁进行保护，相对于HashTable的synchronized锁的粒度更精细了一些，并发性能更好，而HashMap没有锁机制，不是线程安全的。（JDK1.8之后ConcurrentHashMap启用了一种全新的方式实现,利用CAS算法。） HashMap的键值对允许有null，但是ConCurrentHashMap都不允许。 ConcurrentHashMap 和 Hashtable 的区别？ ConcurrentHashMap 和 Hashtable 的区别主要体现在实现线程安全的方式上不同。 底层数据结构： JDK1.7的 ConcurrentHashMap 底层采用 分段的数组+链表 实现，JDK1.8 采用的数据结构跟HashMap1.8的结构一样，数组+链表/红黑二叉树。Hashtable 和 JDK1.8 之前的 HashMap 的底层数据结构类似都是采用 数组+链表 的形式，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的； 实现线程安全的方式（重要）： ① 在JDK1.7的时候，ConcurrentHashMap（分段锁） 对整个桶数组进行了分割分段(Segment)，每一把锁只锁容器其中一部分数据，多线程访问容器里不同数据段的数据，就不会存在锁竞争，提高并发访问率。（默认分配16个Segment，比Hashtable效率提高16倍。） 到了 JDK1.8 的时候已经摒弃了Segment的概念，而是直接用 Node 数组+链表+红黑树的数据结构来实现，并发控制使用 synchronized 和 CAS 来操作。（JDK1.6以后 对 synchronized锁做了很多优化） 整个看起来就像是优化过且线程安全的 HashMap，虽然在JDK1.8中还能看到 Segment 的数据结构，但是已经简化了属性，只是为了兼容旧版本；② Hashtable(同一把锁) :使用 synchronized 来保证线程安全，效率非常低下。当一个线程访问同步方法时，其他线程也访问同步方法，可能会进入阻塞或轮询状态，如使用 put 添加元素，另一个线程不能使用 put 添加元素，也不能使用 get，竞争会越来越激烈效率越低。 两者的对比图： HashTable: JDK1.7的ConcurrentHashMap： JDK1.8的ConcurrentHashMap（TreeBin: 红黑二叉树节点 Node: 链表节点）： 答：ConcurrentHashMap 结合了 HashMap 和 HashTable 二者的优势。HashMap 没有考虑同步，HashTable 考虑了同步的问题。但是 HashTable 在每次同步执行时都要锁住整个结构。 ConcurrentHashMap 锁的方式是稍微细粒度的。 ConcurrentHashMap 底层具体实现知道吗？实现原理是什么？ JDK1.7 首先将数据分为一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据时，其他段的数据也能被其他线程访问。 在JDK1.7中，ConcurrentHashMap采用Segment + HashEntry的方式进行实现，结构如下： 一个 ConcurrentHashMap 里包含一个 Segment 数组。Segment 的结构和HashMap类似，是一种数组和链表结构，一个 Segment 包含一个 HashEntry 数组，每个 HashEntry 是一个链表结构的元素，每个 Segment 守护着一个HashEntry数组里的元素，当对 HashEntry 数组的数据进行修改时，必须首先获得对应的 Segment的锁。 该类包含两个静态内部类 HashEntry 和 Segment ；前者用来封装映射表的键值对，后者用来充当锁的角色；Segment 是一种可重入的锁 ReentrantLock，每个 Segment 守护一个HashEntry 数组里得元素，当对 HashEntry 数组的数据进行修改时，必须首先获得对应的 Segment 锁。 JDK1.8 在JDK1.8中，放弃了Segment臃肿的设计，取而代之的是采用Node + CAS + Synchronized来保证并发安全进行实现，synchronized只锁定当前链表或红黑二叉树的首节点，这样只要hash不冲突，就不会产生并发，效率又提升N倍。 结构如下： 如果该节点是TreeBin类型的节点，说明是红黑树结构，则通过putTreeVal方法往红黑树中插入节点；如果binCount不为0，说明put操作对数据产生了影响，如果当前链表的个数达到8个，则通过treeifyBin方法转化为红黑树，如果oldVal不为空，说明是一次更新操作，没有对元素个数产生影响，则直接返回旧值；如果插入的是一个新节点，则执行addCount()方法尝试更新元素个数baseCount； 辅助工具类 Array 和 ArrayList 有何区别？ Array 可以存储基本数据类型和对象，ArrayList 只能存储对象。Array 是指定固定大小的，而 ArrayList 大小是自动扩展的。Array 内置方法没有 ArrayList 多，比如 addAll、removeAll、iteration 等方法只有 ArrayList 有。 对于基本类型数据，集合使用自动装箱来减少编码工作量。但是，当处理固定大小的基本数据类型的时候，这种方式相对比较慢。 如何实现 Array 和 List 之间的转换？ Array 转 List： Arrays. asList(array) ；List 转 Array：List 的 toArray() 方法。 comparable 和 comparator的区别？ comparable接口实际上是出自java.lang包，它有一个 compareTo(Object obj)方法用来排序comparator接口实际上是出自 java.util 包，它有一个compare(Object obj1, Object obj2)方法用来排序 一般我们需要对一个集合使用自定义排序时，我们就要重写compareTo方法或compare方法，当我们需要对某一个集合实现两种排序方式，比如一个song对象中的歌名和歌手名分别采用一种排序方法的话，我们可以重写compareTo方法和使用自制的Comparator方法或者以两个Comparator来实现歌名排序和歌星名排序，第二种代表我们只能使用两个参数版的Collections.sort(). 方法如何比较元素？ TreeSet 要求存放的对象所属的类必须实现 Comparable 接口，该接口提供了比较元素的 compareTo()方法，当插入元素时会回调该方法比较元素的大小。TreeMap 要求存放的键值对映射的键必须实现 Comparable 接口从而根据键对元素进 行排 序。 Collections 工具类的 sort 方法有两种重载的形式， 第一种要求传入的待排序容器中存放的对象比较实现 Comparable 接口以实现元素的比较； 第二种不强制性的要求容器中的元素必须可比较，但是要求传入第二个参数，参数是Comparator 接口的子类型（需要重写 compare 方法实现元素的比较），相当于一个临时定义的排序规则，其实就是通过接口注入比较元素大小的算法，也是对回调模式的应用（Java 中对函数式编程的支持）。

详细解答可以参考官方帮助文档 以下接口调用时，如有回调，均为异步执行，且回调不能为空。 1.1基本设置 SDK注册 初始化推送SDK，关联到云通道。 参数 context 应用上下文（需要ApplicationContext）callback 回调 void register(Context context, CommonCallback callback); SDK动态注册接口 支持动态设置appKey，appSecret的注册接口 参数 context 应用上下文（需要ApplicationContext）appKey appSecretcallback 回调 void register(Context context, String appKey, String appSecret, CommonCallback callback); 启动信息统计 统计App启动信息。 void onAppStart(); 获取设备标识 获取设备唯一标识。 返回 设备唯一标识。 String getDeviceId(); 设置日志等级 需要在通道初始化之前设置；默认日志等级为CloudPushService.ERROR； 参数 logLevel 支持设置：CloudPushService.ERROR | CloudPushService.INFO | CloudPushService.DEBUG | CloudPushService.OFF（关闭Log） void setLogLevel(int logLevel); V2.3.6及以上版本支持)" class="reference-link">动态设置appKey(V2.3.6及以上版本支持) 动态设置appKey无需在manifest配置appKey务必在调用register注册接口之前调用该接口，否则动态设置失效 参数 appKey 需要设置的appKey void setAppKey(String appKey); V2.3.6及以上版本支持)" class="reference-link">动态设置appSecret(V2.3.6及以上版本支持) 动态设置appSecret无需在manifest配置appSecret务必在调用register注册接口之前调用该接口，否则动态设置失效 参数 appSecret 需要设置的appSecret void setAppSecret(String appSecret); V3.0.3及以上版本支持)" class="reference-link">打开推送通道(V3.0.3及以上版本支持) 用于在程序运行时动态打开推送通道全量推送场景下，打开推送通道存在2-3小时延迟。其他场景实时生效 参数 callback 回调 void turnOnPushChannel(CommonCallback callback); V3.0.3及以上版本支持)" class="reference-link">关闭推送通道(V3.0.3及以上版本支持) 用于在程序运行时动态关闭推送通道全量推送场景下，关闭推送通道存在2-3小时延迟。其他场景实时生效 参数 callback 回调 void turnOffPushChannel(CommonCallback callback); V3.0.3及以上版本支持)" class="reference-link">查询推送通道状态(V3.0.3及以上版本支持) app运行时查询当前推送通道状态如果当前为打开状态，则通过callback.success(String response)回调传入’on’;反之则传入’off’ 参数 callback 回调 void checkPushChannelStatus(CommonCallback callback); V3.0.10及以上版本支持)" class="reference-link">设置消息接收IntentService(V3.0.10及以上版本支持) 通过IntentService组件接收消息回调设置后消息将通过该组件透出，不再通过MessageReceiver设置的IntentService需继承com.alibaba.sdk.android.push.AliyunMessageIntentService，并覆写相关回调方法 参数 messageIntentService 自定义接收消息IntentService的class void setPushIntentService(Class messageIntentService); 1.2 账号API 绑定账号 将应用内账号和推送通道相关联，可以实现按账号的定点消息推送；设备只能绑定一个账号，同一账号可以绑定到多个设备；同一设备更换绑定账号时无需进行解绑，重新调用绑定账号接口即可生效；若业务场景需要先解绑后绑定，在解绑账号成功回调中进行绑定绑定操作，以此保证执行的顺序性；账户名设置支持64字节。 参数 account 绑定账号名callback 回调 void bindAccount(String account, CommonCallback callback); 解绑账号 将应用内账号和推送通道取消关联。 参数 callback 回调 void unbindAccount(CommonCallback callback); 1.3 标签API 绑定标签 绑定标签到指定目标；支持向设备、账号和别名绑定标签，绑定类型由参数target指定；绑定标签在10分钟内生效；App最多支持绑定1万个标签，单个标签最大支持128字符。 参数 target 目标类型，1：本设备； 2：本设备绑定账号； 3：别名target(V2.3.5及以上版本) 目标类型，CloudPushService.DEVICE_TARGET：本设备； CloudPushService.ACCOUNT_TARGET：本账号； CloudPushService.ALIAS_TARGET：别名tags 标签（数组输入）alias 别名（仅当target = 3时生效）callback 回调 void bindTag(int target, String[] tags, String alias, CommonCallback callback); 解绑标签 解绑指定目标标签；支持解绑设备、账号和别名标签，解绑类型由参数target指定；解绑标签在10分钟内生效；解绑标签只是解除设备和标签的绑定关系，不等同于删除标签，即该APP下标签仍然存在，系统目前不支持标签的删除。 参数 target 目标类型，1：本设备； 2：本设备绑定账号； 3：别名。target(V2.3.5及以上版本) 目标类型，CloudPushService.DEVICE_TARGET：本设备； CloudPushService.ACCOUNT_TARGET：本账号； CloudPushService.ALIAS_TARGET：别名tags 标签（数组输入）alias 别名（仅当target = 3时生效）callback 回调 void unbindTag(int target, String[] tags, String alias, CommonCallback callback); 查询标签 查询目标绑定标签，当前仅支持查询设备标签；查询结果可从回调onSuccess(response)的response获取；标签绑定成功且生效（10分钟内）后即可查询。 参数 target 目标类型，1: 本设备target(V2.3.5及以上版本) 目标类型，CloudPushService.DEVICE_TARGET：本设备；callback 回调 void listTags(int target, CommonCallback callback); 1.4 别名API 添加别名 设备添加别名；单个设备最多添加128个别名，且同一别名最多添加到128个设备；别名支持128字节。 参数 alias 别名callback 回调 void addAlias(String alias, CommonCallback callback); 删除别名 删除设备别名；支持删除指定别名和删除全部别名（alias = null || alias.length = 0）。 参数 alias 别名（alias = null or alias.length = 0时，删除设备全部别名）callback 回调 void removeAlias(String alias, CommonCallback callback); 查询别名 查询设备别名；查询结果可从回调onSuccess(response)的response中获取；从V3.0.9及以上版本开始，接口内部有5s短缓存，5s内多次调用只会请求服务端一次。 参数 callback 回调 void listAliases(CommonCallback callback); 1.5 通知设置API 设置通知声音 设置推送通知声音文件路径；若不调用本接口，默认获取资源id为R.raw.alicloud_notification_sound的资源文件；若没有获取到指定声音文件，取设备设置的消息声音。 参数 filePath 通知声音文件路径 void setNotificationSoundFilePath(String filePath); 设置通知栏图标 设置推送通知栏图标资源Bitmap。若不调用本接口，默认获取id为R.drawable.alicloud_notification_largeIcon的资源文件；若没有获取到指定图标文件，取App启动图标。 参数 icon 图标资源Bitmap void setNotificationLargeIcon(Bitmap icon); 设置状态栏图标 设置推送状态栏图标资源Id；若不调用本接口，默认获取id为R.drawable.alicloud_notification_smallIcon的资源文件；若没有获取到指定资源文件Id，取App启动图标。 参数 iconId 图标资源Id void setNotificationSmallIcon(int iconId); 设置免打扰时段 设置免打扰时间段，过滤所有通知与消息；免打扰时段仅支持设置一次，多次调用以最后一次调用设置时段为准；设置免打扰时段为00:00 - 00:00，可取消免打扰功能；(以下功能支持该用法，V2.3.5及以上版本使用关闭免打扰功能接口)全天免打扰可以设置为”0:0-23:59”免打扰时段设置对小米辅助弹窗通知无效。 参数 startHour 免打扰的起始时间（小时），24小时制，取值范围：0-23startMinute 免打扰起始时间（分钟），取值范围：0-59endHour 免打扰的结束时间（小时），24小时制，取值范围：0-23endMinute 免打扰结束时间（分钟），取值范围：0-59 void setDoNotDisturb(int startHour, int startMinute, int endHour, int endMinute, CommonCallback callback); V2.3.5及以上版本支持）" class="reference-link">关闭免打扰功能（V2.3.5及以上版本支持） 关闭后，先前设置的免打扰时段失效免打扰功能默认是关闭的没有对应的开发免打扰功能接口，调用设置免打扰功能时段功能后自动打开免打扰功能 void closeDoNotDisturbMode(); V2.3.7及以上版本支持)" class="reference-link">删除所有通知接口(V2.3.7及以上版本支持) 删除推送SDK创建的所有通知若需要实现精准删除特定通知可以在onNotification回调中获取通知id，自行删除 void clearNotifications(); V3.0.6及以上版本支持)" class="reference-link">1.6 自建通知统计上报API(V3.0.6及以上版本支持) 本接口主要针对统计用户自建通知（通过阿里云推送发送透传消息，并在onMessage回调中自行创建通知）的删除/点击事件上报，其相关实现可以参考移动推送Android SDK：透传消息+用户自建通知最佳实践，如果您直接通过阿里云推送通知，无需使用相关接口。 自建通知点击上报接口 上报自建通知的点击事件请确保同一消息仅上报一次 参数 message 要上报点击事件的消息实例 void clickMessage(CPushMessage message); 自建通知删除上报接口 上报自建通知的删除事件请确保同一消息仅上报一次 参数 message 要上报删除事件的消息实例 void dismissMessage(CPushMessage message); V3.0.11及以上版本支持)" class="reference-link">1.7 电话API(V3.0.11及以上版本支持) 为提高信息的到达率和实效性，扩展推送的使用场景，我们推出了推送与短信的融合通知模式。开发者可以设置在一定时间内，如果用户未收到或未点击推送，通过短信补发通知用户。具体方案可参考：推送短信融合。 为实现推送短信融合方案，需要在终端接入绑定/解绑电话号接口，接口详情如下。 绑定电话号将设备与电话号绑定 参数 phoneNumber 要绑定的手机号callback 回调 void bindPhoneNumber(String phoneNumber, CommonCallback callback); 解绑电话号解除当前设备与电话号的绑定关系 参数 callback 回调 void unbindPhoneNumber(CommonCallback callback);

引用来自“TymonHuang”的评论 改成这样了也不行，    int*p;   int**a;   inti;   a=malloc(sizeof(int*)*3);   for(i=0;i<3;i++){       p=a[i];       p=malloc(sizeof(int));       *p=i;   }   intv;   for(i=0;i<3;i++){       p=(a[i]);       v=(*p);       printf("%d\n",v);   }p=a[i]; 这个时候a[i]并没有分配内存。现在a占着3个int*的内存，但是int*指向哪里并没有分配。所以不能赋值给p。 ######c######恩恩，是的，我刚开始是这样理解的，p=a[i],p就指向了a[i],接着p=malloc(sizeof(int));就等于分配内存给a[i]了，其实这里也错了。######恩######a都没初始化，哪来的a[i]？？######int**a=(int**)malloc(sizeof(int*));######a=malloc(sizeof(int*));*a=malloc(sizeof(int*));以上均不行。###### a=malloc(sizeof(int*)*3); ######看你要怎样的指针了，如果是要动态分配二维数组，用楼上的方式，如果是要分配一个二级指针，这个指针指向一个一维数组，就 int**a=(int**)malloc(sizeof(int*));，这2种方式分配的内存结构是不同的######其实很简单###### 改成这样了也不行，    int*p;   int**a;   inti;   a=malloc(sizeof(int*)*3);   for(i=0;i<3;i++){       p=a[i];       p=malloc(sizeof(int));       *p=i;   }   intv;   for(i=0;i<3;i++){       p=(a[i]);       v=(*p);       printf("%d\n",v);   }######    a=(int**)malloc(sizeof(int*)*3);    for(i=0;i<3;i++){     a[i]  =(int*)malloc(sizeof(int));        *(a[i])=i;    } ######既然你都叫做“二级指针”了。也应该知道有两层级的地址存储空间啊。空间声明代码，int**a，只给了一个层级的空间，另一个层级的空间要么静态声明，要么动态申请。哈。

引用来自“TymonHuang”的评论 改成这样了也不行，     int *p;     int **a;     int i;     a = malloc(sizeof(int *) * 3);     for (i = 0; i < 3; i++) {         p = a[i];         p = malloc(sizeof(int));         *p = i;     }     int v;     for (i = 0; i < 3; i++) {         p = (a[i]);         v = (*p);         printf("%d\n", v);     } p = a[i]; 这个时候a[i]并没有分配内存。现在a占着3个int*的内存，但是int*指向哪里并没有分配。所以不能赋值给p。 ######c######恩恩， 是的， 我刚开始是这样理解的， p = a[i], p就指向了a[i], 接着 p = malloc(sizeof(int)); 就等于分配内存给a[i]了， 其实这里也错了。######恩######a都没初始化，哪来的a[i]？？######int **a = (int**)malloc(sizeof(int*));######a = malloc(sizeof(int*)); *a = malloc(sizeof(int*)); 以上均不行。###### a = malloc(sizeof(int*) * 3); ######看你要怎样的指针了，如果是要动态分配二维数组，用楼上的方式，如果是要分配一个二级指针，这个指针指向一个一维数组，就 int **a = (int**)malloc(sizeof(int*));，这2种方式分配的内存结构是不同的######其实很简单###### 改成这样了也不行，     int *p;     int **a;     int i;     a = malloc(sizeof(int *) * 3);     for (i = 0; i < 3; i++) {         p = a[i];         p = malloc(sizeof(int));         *p = i;     }     int v;     for (i = 0; i < 3; i++) {         p = (a[i]);         v = (*p);         printf("%d\n", v);     } ######     a = (int **)malloc(sizeof(int *) * 3);     for (i = 0; i < 3; i++) {         a[i]  =(int *)malloc(sizeof(int));         *(a[i]) = i;     } ######既然你都叫做“二级指针”了。也应该知道有两层级的地址存储空间啊。空间声明代码，int **a，只给了一个层级的空间，另一个层级的空间要么静态声明，要么动态申请。哈。