黑马程序员---------java 基础知识复习（foreach、Arrays、String、StringBuffer、容器类）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

java 基础知识复习

1、foreach语句遍历数组
2、使用Arrays类对数组进行操作
3、String/StringBuffer类的使用
4、Date/Calendar/DateForat等类的使用
5、容器类介绍 List/Set/Map
ArrayList/LinkedList, HashSet/TreeSet

一、foreach语句遍历数组（增强的for循环）

int a[] = new int[10];
for(int i=0;i<10;i++)
{
a[i] = 2*i + 3;
}
//     for(int i=0;i<10;i++)
//     {
//     System.out.print(a[i] + " ");
//     }

//foreach语句，每遍历一次，就把数组的当前元素的值赋给迭代变量
//i,i就代表当前元素的值。
//注意：foreach只能遍历数组，不能改变数组元素的值

for(int i:a)
{
　　System.out.print(i + " ");
}

Iterator 迭代器 遍历一个容器对象

二、Arrays类提供了对数组的一些常用操作。比如排序，将数组转化为List对象，可以进行查找（提供了二分法查找），判断两个数组是否相等的方法。

java.util.Arrays
static List asList()：将一个数组转换为List对象。将数组作为一个整体 放到List对象中（变成了List中的一个元素）
fill(type a[],T key):将数组a的所有元素的值填充为key
boolean equals(type a[],type b[]):两个数组相等的条件：长度相同，对应位置的值相等。

三、String、StringBuffer类的使用
在Java中使用String表示字符串。在Java中声明字符串的方法有两种：
(1)
String s = “Java”; //将一个字符串常量”Java”赋给变量s
(2)
String s = new String(“Java”);
这种方法在内存中又开辟一段空间，在该空间存储一个字符串”Java”;
getBytes(String encoding):将字符串转换为字节数组;

1、StringBuffer
StringBuffer的功能比String强，在对字符串的CRUD方面性能比String效率高。
另外，StringBuffer 提供了默认为16个字节的缓冲区。

构造方法：
StringBuffer()：构建一个空字符串，默认的capacity大小为16字节
StringBuffer(String s)：构建一个字符串s，默认的capacity大小为16字节
StringBuffer(int cap)：指定capacity大小为cap的字符串

StringBuffer s = new StringBuffer(100);
System.out.println("capacity:" + s.capacity());
System.out.println("length:" + s.length());

s.append("hello");//在尾部追加
s.insert(3, "java"); //在第3字符串之前插入，0序开始
System.out.println(s);
s.delete(3,4); //删除[start,end)
reserve()：执行完毕之后，字符串的内容反转。
trimToSize()：将字符串的capacity设置为length长度一致。

String s1 = "java";
String s2 = new String("java");
String s3 = new String("java");

StringBuffer s4 = new StringBuffer("java");
StringBuffer s5 = new StringBuffer("java");
//在String类中,重写了equals()，String类中的
//equals()是比较两个字符串的内容是否一致。
//==是比较两个字符串的地址是否相等
System.out.println(s1.equals(s2));//true
System.out.println(s1==s2);//false
System.out.println(s3.equals(s2)); //true
System.out.println(s3==s2);//false
//在StringBuffer类继承Object类，并且没有重写equals()
//equals()与==的功能 是一样的，比较地址是否相等。
System.out.println(s4.equals(s5)); //false
System.out.println(s4==s5);//false
//
System.out.println(s4.equals(s3)); //false
//s6指s5的地址
StringBuffer s6 = s5;
System.out.println(s6.equals(s5)); //true
System.out.println(s6==s5);//true

四、容器
容器解决了数组的两个问题：容器的长度可变；容器放置的元素可以类型不一致（一旦元素放到容器中之后，将先转换为Object类型）。
当元素从容器中取出来时，类型为Object类型，要进行相应的类型转换。使用泛型(Genic)可以不用再进行类型转换。
String i = “100”;
List list = new ArrayList();
list.add(i);//转换为Object类型
//取出i，i此时为Object
String s = (String)list.get(0);

使用泛型的情况：
String i = “100”;
List<String> list = new ArrayList<String>();
list.add(i);//转换为Object类型
//取出i，i此时为Object
String s = list.get(0);

容器类的继承关系：
在Java中定义了两种容器对象：Collection(集合)和Map（映射）
Collection像数列
“abc”,13,”java”,64,new Date()……
Map像数据字典
Key(键) Value(值)
Name “zhangsan”
Age 19
…… ……

Collection接口又分为两类：List、Set

Collection/List/Set/Map都是接口。
void method(T E)
Element：元素<E>
Key：Map(<K>,<V>)，键名
Value:值<V>
Type: 任意类型

Collection接口中的方法：
add(E e)：将元素e添加到容器中，追加
addAll(Collection c)将容器c所有元素添加到容器中。
clear()：清空容器
contains(Object o)：判断 o是否包含在容器中。
isEmpty()：判断容器是否为空
Iterator iterator()：返回一个迭代器对象，通过该迭代器可以遍历容器。
Iterator接口中有两个重要方法：next()返回容器中的下一个元素。hasNext()判断容器中是否还有元素。
size()：返回容器中元素的个数。

容器的访问与遍历

Collection c = new ArrayList();
        c.add("java");
        c.add(100);
        c.add(new Date());
    
        //取得容器中的元素
        //System.out.println(((ArrayList)c).get(2));
        //遍历容器
        Iterator it = c.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
        
        for(int i=0;i<c.size();i++)
        {
            System.out.println(((ArrayList)c).get(i));
        }

List接口和ArrayList类

String s1 = "hello";
        String s2 = "Java ";
        String s3 = "0371-23526435";
        String s4 = "Hibernate";
        String s5 = "Struts";
        String s6 = "Spring";
        String s7 = "MVC";
        String s8 = "IoC/AOP"; //Inverse of Control
        //Aspect Oriented Programming
        //向上转型，编译时具有父类的特点，运行时调用的是子类的方法，成员变量使用的父类
        List<String> stringList = new ArrayList<String>();
        stringList.add(s1);
        stringList.add(s2);
        stringList.add(s3);
        stringList.add(s4);
        stringList.add(s5);
        stringList.add(s6);
        stringList.add(s7);
        stringList.add(s8);
        //如果不加泛型，需要强制类型转换，将Object类型转换为目标类型
        String data = (String)stringList.get(0);
        //容器、数组都是0序开始的。
        
        //stringList.clear();
        stringList.add(0, "data");
        stringList.add(3,"two");
        stringList.add(7,"two");
        //System.out.println(stringList);
        System.out.println(stringList.lastIndexOf("two"));
        Iterator<String> it = stringList.iterator();
//        while(it.hasNext())
//        {
//            System.out.print(it.next() + "  ");
//            //it.remove();
//        }
        
        ListIterator<String> li = stringList.listIterator();
        
        System.out.println(li.hasPrevious());
        while(li.hasNext())
        {
            System.out.print(li.next() + "  ");
            
        }
        
        System.out.println();
        
        while(li.hasPrevious())
        {
            System.out.print(li.previous() + "  ");
        }
        System.out.println();
        
        List<String> temp = stringList.subList(2, 7);
        System.out.println(temp);

4、Iterator接口
Iterator接口可以对容器对象进行遍历，而且还可以删除指定的元素。
Boolean hasNext()：判断容器是否还有元素。
E next():返回下一个元素。
void remove():删除容器中的最后一个元素。

5、Set
set是一个无序的集合，添加元素的次序与实际保存的元素次序无关。不能添加重复的元素。

Set<Integer> set = new HashSet<Integer>();
        set.add(235);
        set.add(634);
        set.add(74);
        set.add(-3465);
        set.add(74);
        set.add(null);
    
        Set<String> s = new TreeSet<String>();
        s.add("aa");
        s.add("ab");
        s.add("dd");
        s.add("ce");
        System.out.println(s);

Map接口与HashMap类
Boolean containsKey(Object key)：判断map对象是否含有key对象
Boolean containsValue(Object value)：判断map对象是否含有value对象
entrySet():将Map对象转换为Set对象
Value get(Object key):获取map中的某一个元素
keySet()：将一个map对象的key转换为Set对象
put(Object key,Object value)：向map中添加一对键值对
size()：返回map对象有多少个键值对。

package com.chde6;
import java.util.*;
public class HashMapDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        HashMap<String,Person> map = new HashMap<String,Person>();
        map.put("zhangsan",new Person("zhangsan",20,"男"));
        map.put("tom",new Person("tom",20,"男"));
        map.put("jack",new Person("jack",22,"男"));
        map.put("mike",new Person("mike",23,"男"));
//        map.put(1, 100);
//        map.put("k1", "Java");
        Set<?> set = map.entrySet();
        Iterator<?> it = set.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
            
        }
        System.out.println(map);
        
        if(map.containsKey("tom"))
        {
            System.out.println(map.get("tom"));
        }
        
        Set s = map.keySet();
        Iterator i = s.iterator();
        while(i.hasNext())
        {
            System.out.println(map.get(i.next()));
        }
    }
}

class Person
{
    private String name;
    private int age;
    private String sex;
    public Person(String name, int age, String sex) {
        super();
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + ", sex=" + sex + "]";
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    
}