学习笔记 java学习（九）

泛型
1.格式： <?> …
2.泛型的来由：想要模拟数组数据类型检查，也相对集合数据类型做限制
3.使用：通常与集合一起使用，为了限制类型，而且可以把报错时机提前
4.泛型是一颗“语法糖”，只在编译时检查类型，编译好的字节码文件中没有泛型
5.泛型方法
public static void print(E[] a){}–两处位置必须同时出现
注意事项：类型必须使用引用类型，不可以使用基本类型

例题：

package cn.tedu.generic;

import java.util.ArrayList;
import java.util.List;

/**苯类用于测试泛型的优点一*/
public class TestGeneric1 {
    public static void main(String[] args) {
        /**1.泛型怎么来的？*/
        String[] a=new String[5];//创建一个长度为5的String类型的数组
        a[0]="泡泡";
        a[1]="泡泡";
        a[2]="泡泡";
        a[3]="泡泡";
        /**数组可以在编译时期就检查数据的类型，只不是规定的类型
         * 就会在编译器中报错，不需要运行程序就可以看得到*/
        List list=new ArrayList();
        list.add("江江");
        list.add(1);
        list.add(1.6);
        /**引入泛型-牧师是通过泛型来约束集合中的元素类型<?></>*/
        /**泛型的好处：可以把报错的时机提前，在编译期就报错
         * 而不是运行以后才抛出异常，在向集合添加元素时，会先检查元素的类型
         * 不是要求的类型就会编译失败*/
        List<String> list2=new ArrayList<String>();
        list2.add("sss");
        //list2.add(2);
        /**<type>--type的值应该如何去写？
         * 需要查看要存放的类型是什么，根据业务类型自定义
         * 但是type必须是引用类型，不能是基本类型*/
        //List<int>list3=new ArrayList();报错
        List<Integer>list3=new ArrayList();
    }
}

例题2：
package cn.tedu.generic;
/*本类用于泛型的优点测试2/
public class TestGeneric2 {
public static void main(String[] args) {
Integer[] a={1,2,3,4,5,6,7,8,9,10};
print(a);
String[] b={“大哥”,“二哥”,“三哥”,“四哥”};
print(b);
Double[] c={0.6,0.66,0.666,0.6666,6.6};
print©;
}

private static void print(Integer[] a) {
    for(int i=0;i<=a.length-1;i++){
        System.out.println(a[i]);
    }
    /**高效for循环
     * 使用场景;只要对数据从头到尾的遍历一次
     * 好处：比普通for循环语法简单，效率高
     * 缺点：没办法按照下标来操作元素，只能从头到尾的遍历
     * 语法：for（2 3：1）{循环体}
     * 1指的是你要遍历的数据
     * 2是指本轮遍历得到的具体元素的类型 3指的是遍历得到的元素的名字*/
}
/**1.泛型可以写出更加通用的代码，E表示Element元素
 * 2.泛型方法的语法要求：
 * 必须两处同时出现：一个是方法参数类型是泛型E[]
 * 另一个是返回值类型前加泛型<E>
 *     这两处一起表示这是一个泛型方法*/
private static <E> void print(E[] s){
    for(E j:s){
        System.out.println(j);
    }
}
private static void print(Double[] a) {
    //for(int i=0;i<=a.length;i++){
      //  System.out.println(a[i]);
    //}
    for(Double i : a){
      System.out.println(i);
    }
}
private static void print(String[] a) {

    for(int i=0;i<=a.length-1;i++){
        System.out.println(a[i]);
    }}

}

实参：实际参数，有实际意义，实际值的参数名
形参：形式参数，没有具体的值，主要是为了方法传参数进来中转一下

增强for循环
for(本轮遍历到的元素的类型 自定义的变量名 : 要遍历的内容){
循环体；
}
好处：语法简单效率高
坏处：只能从头到尾遍历一次，不能设置步长(普通循环中的更改条件，i如何变化)

Collection接口

例题：

package cn.tedu.collection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;

//本类用于测试colloection接口
public class TestCollection {
    public static void main(String[] args) {


        Collection<Integer> c = new ArrayList();
        c.add(100);
        c.add(200);
        c.add(300);
        c.add(400);
        c.add(500);
        System.out.println(c);
        //c.clear();//清除集合中所有元素
        //System.out.println(c);
        System.out.println(c.hashCode());
        System.out.println(c.toString());
        System.out.println(c.equals(200));
        System.out.println(c.contains(200));
        System.out.println(c.remove(100));
        System.out.println(c.isEmpty());
        System.out.println(c);
        System.out.println(c.size());
        Object[] array=c.toArray();//将指定的集合转为数组Object[]
        System.out.println(Arrays.toString(array));
        Collection<Integer> c2=new ArrayList<>();
        c2.add(2);
        c2.add(4);
        c2.add(5);
        System.out.println(c2);
        c.addAll(c2);//将c2添加到c中
        System.out.println(c);
        System.out.println(c2);
        System.out.println(c.containsAll(c2));
        System.out.println(c.contains(100));
        System.out.println(c.removeAll(c2));//删除c中包含c2的元素
        System.out.println(c);
        //3.迭代集合、遍历集合
        /**迭代步骤
         * 1.获取集合的迭代器c.interator()
         * 2.判断集合中是否有下一个可迭代的元素 it.hasNext()
         * 3.获取当前迭代到的元素 it.next()*/
        Iterator<Integer> it=c.iterator();
        while(it.hasNext()){
            Integer nub=it.next();
            System.out.println(nub);
        }
    }
}

List接口
例题：

package cn.tedu.collection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

//苯类用于测试List接口
public class TestList {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        //1.创建list的堕胎对象，注意List是接口，不可实例化
        //2.向list集合中存入数据
        list.add("大力娃");
        list.add("大");
        list.add("大力");
        list.add("力娃");
        list.add("娃");
        list.add("大娃");
        list.add("力");
        System.out.println(list);
        //list.clear();//清空集合
        System.out.println(list.contains("力"));//true
        System.out.println(list.equals("力"));//false,集合对象与String数据是否相等
        System.out.println(list.isEmpty());//判断集合是否为空
        System.out.println(list.remove("力"));
        System.out.println(list.size());
        System.out.println(Arrays.toString(list.toArray()));//将集合转为String类输出
        //3,测试List接口自己的方法--List有序，可以根据索引来操作集合中的元素
        list.add("xx");//追加在最后
        list.add("xx");//追加在最后
        list.add(1,"xxx");//在指定位置添加元素
        System.out.println(list.indexOf("xx"));//7.获取指定元素第一次出现的索引位置
        System.out.println(list.lastIndexOf("xx"));//8.获取指定元素最后一次出现的索引位置
        System.out.println(list);
        System.out.println(list.remove(5));//删除指定索引的元素
        System.out.println(list.get(3));//获取指定索引处的元素
        System.out.println(list.set(7,"嘻嘻嘻"));//修改指定索引处元素的值
        System.out.println(list);
        //测试集合间的操作
        List<String> list2=new ArrayList<>();
        list2.add("2");
        list2.add("2");
        list2.add("2");
        list2.add("2");
        System.out.println(list2);
        System.out.println(list.addAll(1,list2));//指定索引添加集合2所有元素
        System.out.println(list.contains(list2));//true
        System.out.println(list.removeAll(list2));
        System.out.println(list);
    }
}