数组、字符串和集合中的增、删、查、改

一.数组

（1.）数组的遍历

(1.)for

int[] arr = new int[n];
for (int i = 0; i < arr.length; i++) {			
}

(2.)foreach

int[] arr = new int[n];
for (int i : arr) {			
}

总结：
foreach遍历方式的特点:
1.简化了遍历
2.foreach没有索引
3.foreach底层还是使用了普通for遍历

编译时期系统会读取foreach的格式,转化普通for格式

 int ai[];
	int k = (ai = arr).length;
	for (int j = 0; j < k; j++)
	{
	int  = ai[j];
		System.out.println(i);
	}

（ 2.）增删查改

• 增：public static void add(int num){} ： 在数组后添加一个int；

public static void add(int num) {
		int[] descArr = Arrays.copyOf(srcArr, srcArr.length + 1);
		descArr[descArr.length - 1] = num;
		srcArr = descArr;
	}

• 删：public static void remove(int index) {} ： 将数组中的某个索引处的元素删除

 	public static void remove(int index) {
		int[] descArr = new int[srcArr.length - 1];
		System.arraycopy(srcArr, 0, descArr, 0, index);
		System.arraycopy(srcArr, index + 1, descArr, index, descArr.length - index);
		srcArr = descArr;
	}

• 查：数组名 [数组索引]
• 改：public static void insert(int index, int num) {} :往数组的任意位置插入一个元素

public static void insert(int index, int num) {
		int[] descArr = new int[srcArr.length + 1];
		System.arraycopy(srcArr, 0, descArr, 0, index);
		descArr[index] = num;
		System.arraycopy(srcArr, index, descArr, index + 1, srcArr.length - index);
		srcArr = descArr;
	}

2.字符串

（1.）字符串的遍历

1.toCharArray()
(1.)char[] toCharArray()： 将字符串转化为字符数组。
(2.)for循环或者foreach遍历字符数组

String s1="HelloWorld";
char[] ch = s1.toCharArray();
		for (char c : ch) {
			System.out.print(c);
		}

2.charAt(int index)
(1.)charAt(int index):输入字符串对应下标获取该下标对应的字符
(2.)for循环遍历（foreach不可用）

String s1="HelloWorld";
		for (int i = 0; i < s1.length(); i++) {
			System.out.println(s1.charAt(i));
		}

（2.）增删查改

• 增：String concat(String str):将指定字符串连接到此字符串的结尾。

   public String concat(String str) {
        int otherLen = str.length();
        if (otherLen == 0) {
            return this;
        }
        int len = value.length;
        char buf[] = Arrays.copyOf(value, len + otherLen);
        str.getChars(buf, len);
        return new String(buf, true);
    }

• 查:
  (1.)indexOf(int ch):输入字符获取对应的下标
  (2.)indexOf(String str) :输入的字符串位于哪个位置
  (3.)int indexOf(int ch,int fromIndex) :从fromIndex索引开始，查找第一次出现ch字符的索引
  (4.)int indexOf(String str,int fromIndex):从fromIndex索引开始，查找第一次出现str字符串的索引
  (5.)int lastIndexOf(int ch) 从后面数;字符ch的索引
• *改
  (1.)String replace(char old,char new) ：替换功能。
  (2.)String replace(String old,String new) ：替换功能。

 public String replace(char oldChar, char newChar) {
        if (oldChar != newChar) {
            int len = value.length;
            int i = -1;
            char[] val = value; /* avoid getfield opcode */

            while (++i < len) {
                if (val[i] == oldChar) {
                    break;
                }
            }
            if (i < len) {
                char buf[] = new char[len];
                for (int j = 0; j < i; j++) {
                    buf[j] = val[j];
                }
                while (i < len) {
                    char c = val[i];
                    buf[i] = (c == oldChar) ? newChar : c;
                    i++;
                }
                return new String(buf, true);
            }
        }
        return this;
    }

• 删:可医用replace将字符或者字符串替换成 “” 来实现删除目的

3.集合

（1.）集合的遍历

(1.)Object[] toArray()

public static void main(String[] args) {
		Collection c = new ArrayList();
		c.add("李逵");
		c.add("武松");
		c.add("武大郎");
		System.out.println(c);		
		Object[] arrs = c.toArray();
		for (int i = 0; i < arrs.length; i++) {
			System.out.println(arrs[i]);
		}

(2.)Iterator iterator():迭代器

Iterator  it = c.iterator();//获取迭代器，并创建迭代器对象
		while (it.hasNext()) {
			object e =  it.next();
			System.out.println(e);
		}

（2.）增删查改

• 增：
  （1.）boolean add(Object obj) ：在后面添加object类对象
  （2.） boolean addAll(Collection c) :在后面添加一个集合
• 删：：
  （1.）void clear() ： 清空集合
  （2.）boolean remove(Object o) ：删除某个object类对象
  （3.）boolean removeAll(Collection<?> c)：删除任意集合对象
• 查：（遍历思想）
  （1.） Iterator iterator()
  （2.）Object[] toArray()
  （3.） T[] toArray(T[] a)
• **改：**可以利用删除的方法实现；