java 数据结构详解，数组，集合，HashMap

数组的特性：

数组在内存中是一块连续的存储单元存储起来的，声明数组的时候我们必须声明其长度，这样才会为我们声明一个连续的存储区域。

这种存储方式造成我们想要往数组中存储一个数据时那么其后面各个元素都要往后移动，同样的，删除数据后面的数据都要往前移动。

但是同样也带来好处，我们要想获取数组中第i个元素，直接通过角标获取即可，同理修改也是。

数组获取某一数据很简单通过角标i直接获取即可，但是增删比较低效，在内存中用一块连续的存储区域来存储，查找数组中是否包含某一元素比较低效。

数据结构之链表

与数组不同，链表不用非要一块连续的存储区域，链表是一种离散存储结构，数据之间通过指针链接，每个数据元素包含数据域与指针域，数据域存储对应数据即可，而指针域则指向下一个数据元素（对于单项链表来说），针对指针域还可以分为单向链表，双向链表，循环链表。

链表增删效率高，查找效率低。每一个数据项与数组相比更耗内存。不需要整块内存块，不会造成碎片化。

数据结构之哈希表

哈希表就是一种以键-值(key-indexed) 存储数据的结构，我们只要输入待查找的值即key，即可查找到其对应的值。

LinkedList的队列与栈性质

这里简单提一下。

队列：一种数据结构，最明显的特性是只允许队头删除，队尾插入。

栈：同样是一种数据结构，特性是插入删除都在栈的顶部。

存储时key类型是不确定的，可能是int，可能是String，也可能是其他任意对象。Hash函数的作用就是把这些对象通过合理的方式转为int类型，从而完成数据的存储。

1、数组

数组声明方式有两种

（1）

String [] arrays = {"ab","ac","cc","66","+++"};

arrays[3]="99";//更改值

（2）

String [] arrays =new String[5];

arrays[3]="99";//赋值

1、2删除元素方法。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

public static String[] delete(int index, String array[]) {
   //数组的删除其实就是覆盖前一位
       String[] arrNew = new String[array.length - 1];
   for (int i = index; i < array.length - 1; i++) {
   array[i] = array[i + 1];
   }
//   System.arraycopy(array, 0, arrNew, 0, arrNew.length);
   return arrNew;
   }

   public static String[] delete2(int index, String array[]) {
   //数组的删除其实就是覆盖前一位
       String[] arrNew = new String[array.length - 1];
   for (int i = 0; i < array.length - 1; i++) {
   if (i < index) {
       array[i] = array[i];
   } else {
       array[i] = array[i + 1];
   }
   }

   return arrNew;
   }

1、3调用删除。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

delete2(1,arrays);//调用delete方法

           for(int i=0;i<arrays.length;i++){
       System.out.print(" de==="+arrays[i]);
       }

结果： de===ab de===cc de===66 de===+++ de===+++

1、4数组排序。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

int[] a={1,4,-1,5,0};
Arrays.sort(a);

for(int i=0;i<a.length;i++){
System.out.print(" de==="+a[i]);
}

结果： de===-1 de===0 de===1 de===4 de===5

1、5数组倒序。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

int[] a={1,4,-1,5,0};
       Arrays.sort(a);

       int [] daoxu =new int[a.length];

           for(int i=0;i<a.length;i++){
               daoxu[a.length-i-1] = a[i];
//       System.out.print(" de==="+a[i]);
       }
           for(int i=0;i<daoxu.length;i++){
       System.out.print(" daoxu==="+daoxu[i]);
       }

结果： daoxu===5 daoxu===4 daoxu===1 daoxu===0 daoxu===-1

2、集合

list集合声明

//   static List<String> list2=new ArrayList<>();
//   static List<String> list2=new LinkedList<>();
   static List<String> list2=new Vector<>();

set集合说明

Set<Integer> test = new HashSet<>();

可以 test.add(null);

Set<Integer> test = new TreeSet();

不可以 test.add(null);

说明：

List中的元素有存放顺序，并且可以存放重复元素，检索效率高，插入删除效率低

LinkedList中元素位置是任意的，所以执行插入删除操作效率较高，查询效率较低

Vector多个线程同时访问不会发生不确定的结果，但是它的效率会比较低，如果要考虑线程安全的话可以用它。

Set没有存放顺序，而且不可以存放重复元素，后来的元素会把前面重复的元素替换掉，检索效率低，插入删除效率高

Set存储位置是由它的HashCode码决定的，所以它存储的对象必须有equals()方法，而且Set遍历只能用迭代，因为它没有下标

HashSet是使用Hash表实现的，集合里面的元素是无序得，可以有null值，但是不能有重复元素。

TreeSet是用二叉树结构实现的集合，集合中的元素是有顺序得，不允许放入null，同样不能放入重复元素。

2、2集合操作

Sr.No.	Method & Description
1	add( ) 向集合中添加元素
2	clear( ) 去掉集合中所有的元素
3	contains( ) 判断集合中是否包含某一个元素
4	isEmpty( ) 判断集合是否为空
5	iterator( ) 主要用于递归集合，返回一个Iterator()对象
6	remove( ) 从集合中去掉特定的对象
7	size( ) 返回集合的大小

list2.add("aaa");
           list2.add("bbb");
           list2.add("ccc");
           list2.add("111");
           list2.add("111");

list2.remove(2);//删除元素
           list2.add(2, "插入icom");//插入元素。先删除再插入就是替换元素


           for(int i=0;i<list2.size();i++){
               System.out.print("    ==="+list2.get(i));
               }

结果是： ===aaa ===bbb ===插入icom ===111 ===111

Set遍历：使用迭代方法

Set<Integer> test = new HashSet<>();

int c = 3;
           int d = 9;
           int e = 2;

             test.add(c);
           test.add(d);
           test.add(e);
           test.add(null);

Iterator<Integer> value = test.iterator();
           while (value.hasNext()) {
//           int s = value.next();
           System.out.print(value.next()+" ");
           }

结果：null 2 3 9 ——默认排序了

数组转集合：https://blog.csdn.net/meixi_android/article/details/82221089

3、HashMap

存储键值对我们首先想到HashMap，它的底层基于哈希表，采用数组存储数据，使用链表来解决哈希碰撞，它是线程不安全的

HashMap允许空键值，并且它是非线程安全的，所以插入、删除和定位元素会比较快。

Map map=new HashMap();
   map.put(3, "sss");
   map.put(2, 6666);
   map.put("c", null);
   map.put(null, "ddd");

   System.out.println(map.get(3));

   //遍历
   Iterator iterator = map.keySet().iterator();
   while (iterator.hasNext()) {
   Object key = iterator.next();
   System.out.println("map.get(key) is :"+map.get(key));
   }

结果：sss
map.get(key) is :ddd
map.get(key) is :6666
map.get(key) is :sss
map.get(key) is :null

TreeMap不允许空键值，TreeMap是基于红黑树实现的，适用于按自然顺序火兹定于顺序遍历key。（键需同类型）。如果你需要得到一个有序的结果你就应该使用TreeMap

Map map=new TreeMap();
   map.put(2, "aaa");
   map.put(1, "cccc");
   map.put(4, "bbbbbb");
   map.put(5, "ddd");

   //遍历
   Iterator iterator = map.keySet().iterator();
   while (iterator.hasNext()) {
   Object key = iterator.next();
   System.out.println("map.get(key) is :"+map.get(key));
   }

结果：

map.get(key) is :cccc
map.get(key) is :aaa
map.get(key) is :bbbbbb
map.get(key) is :ddd

HashTable是基于HashCode实现的，但它是线程安全的，所以会比HashMap效率低，而且不允许null值。

Hashtable tab=new Hashtable();
   tab.put("a", "aaa");
   tab.put("b", "bbb");
   tab.put("c", "ccc");
   tab.put("d", "ddd");

   Iterator iterator_1 = tab.keySet().iterator();
   while (iterator_1.hasNext()) {
   Object key = iterator_1.next();
   System.out.println("tab.get(key) is :"+tab.get(key));
   }

结果：

tab.get(key) is :bbb
tab.get(key) is :aaa
tab.get(key) is :ddd
tab.get(key) is :ccc