java study2

Intellj小技巧

数组

1.java数组元素类型是唯一的，即一个数组只能存储一种数据类型的数据，而不能存储多种数据类型的数据。
2.java数组的长度，一旦初始化完成，控件就被固定，即数组的长度将不可改变。。
3.java即可存储基本类型的数据，也可以存储引用类型的数据，只要所有的数组元素类型相同
4.java数组也是一种数据类型，它本身是一种应用类型。例如int是一个基本类型，但int[] 就是一种引用类型了。

定义数组

* type [] arrayName;变量类型 [] 变量名  *推荐*
* type arrayName []; 变量类型 变量名 []
* type [] arrayName = { 变量值,变量值,变量值...};

数组初始化

* 静态初始化

罗列数组的每个元素

#java
int [] intArr;
intArr = new int []{5,6,7,8,20};
Object [] objArr ;
objArr = new String[]{"java","python"};
Object [] objArr2 = new Object[]{"java","python"};

*动态初始化 

直接定义数组的长度：arrayName = new type [length];

#java
int [] intArr = new int [5];
System.out.println(intArr.length);

使用数组

使用下标访问数组的某个元素，可以赋值和取值
System.out.println(intArr[4]);

foreach循环

从java5以来，java提供了一种更简单的循环：foreach循环。语法：
for(type a:array|collection){ //type 变量类型 a:变量 array：数组 collection：集合
System.out.println(a)
}

#java
  public static void main(String[] args){
       int [] intArr = new int [5];
       intArr[0] = 2;
       intArr[3] = 5;
       for (int i:intArr){
           System.out.println(i);
       }
       String [] stringArr = new String [4];
       stringArr[0] = "java";
       stringArr[3] = "python";
       for(String a:stringArr){
           System.out.println(a);
       }

list集合

由于对象数组弱点就是长度的固定，为了解决这个问题，从jdk1.2开始使用集合，处理对象数组，解决长度固定的问题。
数组可以存储基本类型，存储对象；
集合只存储对象，不存储基本类型；
数组和集合是容器：基本数据多了用数组，对象多了用集合
数组和集合的区别：
* 数组定长；集合变长
* 数组存储类型单一，集合存储任意对象
* 数组存储基本类型，对象；集合只存储对象

java中集合有多种类型：

Collection

* List必须保持元素特定的顺序，自动扩展。
* Set不能有重复元素
# Queue保持一个队列（先进先出）的顺序

有人想要自动排序的组数，有了TreeSet,TreeList,Tree**
而几乎所有的集合都是基于数组来实现的。
集合是对数组做的封装，所以数组永远比任何一个集合要快。
但任何一个集合，比数组提供的功能要多：
* 数组声明了它所容纳的元素的类型，而集合不声明。这是由于集合以object形式来存储它们的元素
* 一个数组示例具有固定的答谢，不能伸缩。集合则可根据需要，动态改变大小
* 数组是一种可读可写的结构，没有办法创建一个只读数组。集合提供了ReadOnly()方法，返回一个集合的只读版本。
List接口特有方法：
add(Object o) 在列表的末尾追加一个元素
add(int index,Object o) 在列表的特定位置插入一个元素
remove(Object o) 按元素值删除元素
remove(int index) 按索引删除元素
get(int index) 获取指定位置的元素
set(int index,Object o) 修改指定索引的元素
boolean addAll(int index,Collection c) 在列表的特定位置上插入另一个集合
List subList(int start, int end) 获取集合中的一部分，包含start，不包含end，返回新集合
size 返回列表现在的长度

#java
public static void main(String[] args){
        ArrayList arr1 = new ArrayList();

        arr1.add("1");//add追加一个元素
        arr1.add(2);
        arr1.add(true);
        arr1.add(2,"java");//add(index,element)在特定位置添加
        arr1.add(2,"python");
        //foreach循环
        for(Object o:arr1){
            System.out.println(o);
        }
        System.out.println(arr1);
        System.out.println(""+arr1.indexOf("1"));
        arr1.set(3,"tencent");
        System.out.println(arr1);
        System.out.println(arr1.get(3));
        arr1.remove(2);
        arr1.remove("java");
        List subArr1 = arr1.subList(2,3);
        arr1.addAll(3,subArr1);
        System.out.println(arr1);
        List arr2 = new ArrayList();
        arr2.add("21");
        arr1.addAll(arr2);
        System.out.println(arr1);
        List arr3 = new ArrayList();
        arr3.add("31");
        arr1.addAll(3,arr3);
        System.out.println(arr1);
    }

Map

Map是键值对（key-value）
put 添加键值对
get 通过key获取value

#java
package study1;

import groovy.util.MapEntry;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public class HashMapTest {
    public static void main(String[] args){
        HashMap ha = new HashMap();
        ha.put(1,"java");
        ha.put(2,"python");
        ha.put(3,"ruby");
        ha.put(4,"python");
        System.out.println(ha.get(3));
        //对value进行迭代
        Collection vaules = ha.values();
        System.out.println(vaules);
        for(Object o:ha.values()){
            //Map的key是唯一的，value不是唯一的。即可以根据key获取value，但不能根据value获取key
            //
            System.out.println(o);
        }
        //对key进行迭代
        Collection keys = ha.keySet();
        System.out.println(keys);
        for(Object o:ha.keySet()){
            System.out.println(o);
            System.out.println(ha.get(o));
        }
        Set<MapEntry> entry =  ha.entrySet();
        for(Object o:entry){
            System.out.println("entry"+o);
        }
        Iterator<Object> intor = ha.keySet().iterator();
        System.out.println("intor"+intor);
        while(intor.hasNext()){
            System.out.println(intor.hasNext());
            Object key = intor.next();
            Object value = ha.get(key);
            System.out.print(key+"	");
            System.out.println(value);
        }
    }

}

ruby
[java, python, ruby, python]
java
python
ruby
python
[1, 2, 3, 4]
1
java
2
python
3
ruby
4
python
entry1=java
entry2=python
entry3=ruby
entry4=python
intorjava.util.HashMap$KeyIterator@378bf509
true
1 java
true
2 python
true
3 ruby
true
4 python