集合框架
List
ArrayList去重复方法
public class demo1_ArrayList { public static void main(String[] args) { //创建新集合将重复元素去掉 ArrayList list =new ArrayList(); list.add("a"); list.add("a"); list.add("c"); list.add("c"); list.add("a"); ArrayList newlist=getSing(list); System.out.println(newlist); } public static ArrayList getSing(ArrayList list){ ArrayList newlist = new ArrayList<>();//创建新集合 Iterator it = list.iterator(); //根据传入的集合(老集合)获取迭代器 while (it.hasNext()) { //遍历老集合 Object obj1= it.next(); //记录每一个元素 if (!newlist.contains(obj1)) { //如果新集合不包含老集合中的元素 newlist.add(obj1); //将该元素添加 } } return newlist; } }
import java.util.ArrayList; import java.util.Iterator; /* 重写equals()方法 * contains和remove判断都是依赖equals方法 * */ public class demo2_ArrayList { public static void main(String[] args) { ArrayList list = new ArrayList(); //创建集合对象 list.add(new person("张三",20)); list.add(new person("张三",20)); list.add(new person("张三",20)); list.add(new person("张三",20)); list.add(new person("李四",20)); list.add(new person("赵文",20)); list.add(new person("李四",20)); ArrayList newlist =getSing(list); System.out.println(newlist); } public static ArrayList getSing(ArrayList list){ ArrayList newlist = new ArrayList<>();//创建新集合 Iterator it = list.iterator(); //根据传入的集合(老集合)获取迭代器 while (it.hasNext()) { //遍历老集合 Object obj1= it.next(); //记录每一个元素 if (!newlist.contains(obj1)) { //如果新集合不包含老集合中的元素 newlist.add(obj1); //将该元素添加 } } return newlist; } } //第二个包 public class person { private String name; private int age; 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 person(String name, int age) { super(); this.name = name; this.age = age; } public person() { super(); // TODO Auto-generated constructor stub } @Override public String toString() { return "person [name=" + name + ", age=" + age + "]"; } @Override public boolean equals(Object obj1) { person p=(person)obj1; return this.name.equals(p.name) && this.age == p.age; } }
LinkList的特有功能
public void addFirst( E e)及addFirst(E e)
public E getFirst( )及getLast( )
public E removFirst( ) 及public E remoLast( )
public E get(int index)
public class demo3_LinkedList { public static void main(String[] args) { demo1(); LinkedList list= new LinkedList(); } public static void demo1() { LinkedList list= new LinkedList(); list.addFirst("a"); //添加 list.addFirst("b"); list.addFirst("c"); list.addLast("z"); System.out.println(list); //System.out.println(list.getFirst());//获取 //System.out.println(list.getLast()); System.out.println(list.removeFirst());//删除 System.out.println(list.get(1)); System.out.println(list); } }
栈和队列数据结构
栈：
先进后出
队列：
先进先出
LinkedList模拟栈数据结构的集合并测试
package tan.jung.list; import java.util.LinkedList; import org.xml.sax.ErrorHandler; public class demo4_LinkedList { public static void main(String[] args) { //demo1(); Stack s=new Stack(); s.in("a"); //进栈 s.in("b"); s.in("c"); s.in("d"); while (!s.isEmpty()) { //判断栈是否为空 System.out.println(s.out());//弹栈 } } public static void demo1() { LinkedList list= new LinkedList(); list.addLast("a"); list.addLast("b"); list.addLast("c"); list.addLast("d"); /* System.out.println(list); System.out.println(list.removeLast()); System.out.println(list.removeLast()); System.out.println(list.removeLast()); System.out.println(list.removeLast());*/ while (!list.isEmpty()) { //如果不为空 System.out.println(list.removeLast()); } } } //第二个包 package tan.jung.list; import java.util.LinkedList; public class Stack { private LinkedList list =new LinkedList(); //模拟进栈方法 public void in(Object obj){ list.addLast(obj); } //模拟出栈 public Object out(){ return list.removeLast(); } public boolean isEmpty(){ return list.isEmpty(); } }
泛型generic
泛型的好处：
提高安全性(将运用期的错误转换到编译器)
省去强转的麻烦
泛型基本使用：
< >中放的必须是引用数据类型
泛型使用注意事项
前后的泛型必须一致，或者后面的泛型可以省略不写(1.7的新特性菱形泛型)
package tan.jung.generic; import java.util.ArrayList; import java.util.Iterator; import tan.jung.list.person; public class demo1_generic { public static void main(String[] args) { //demo1(); //ArrayList<person> list =new ArrayList<object>();//集合的泛型要保证前后的数量类型一致 //ArrayList<person> list =new ArrayList<>();//1.7版本的新特性，菱形泛型 ArrayList<object> list =new ArrayList<>(); //泛型最好不要定义成object，没有意义 } public static void demo1() { ArrayList<person> list =new ArrayList<person>(); // list.add("a"); // list.add(true); // list.add(100); list.add(new person("谭某",20)); list.add(new person("某某",22)); Iterator<person> it1=list.iterator(); while (it1.hasNext()) { // person p1=it1.next(); //System.out.println(it1.next().getName()+"..."+it1.next().getAge()); //next方法只能调用一次，如果调用多次会将指针向后移动多次 person p1=it1.next(); System.out.println(p1.getName()+"..."+p1.getAge()); } } }
泛型的由来
泛型的由来：通过object转型问题引入
早起的object类型可以接受任意的对象类型，但是在实际色使用中。会有类型转换的问题，也就存在隐患，所以java提供了泛型来解决这个安全问题
泛型类概述
把泛型定义在类上
定义格式
public class 类名<泛型类型1，...>
注意事项
泛型类型必须是引用类型
泛型的方法
把泛型定义在方法上
public <泛型类型> 返回类型 方法名 (泛型类型 变量名)
泛型接口
把泛型定义在接口
public interface 接口名<泛型类型>
public class demo4_generic { public static void main(String[] args) { } } interface Inter<T>{ public void show(T t); } /*class demo implements Inter<String>{ @Override public void show(String t) { System.out.println(t); } }*/ class demo<T> implements Inter<T>{ //没有必要再实现接口的时候给自己类加泛型 @Override public void show(T t) { System.out.println(t); } }
泛型通配符< ？>
任意类型，如果没有明确，那么就是object以及任意的java类了
？ extends E
向下限定，E及其子类
？super E
向上1限定，E及其父类
public class demo_Generic { public static void main (String args []){ //List<?> list = new ArrayList<Integer>(); //？代表任意类型 当右边的泛型是不确定时，左边可以指定为? ArrayList<person> list1= new ArrayList<>(); list1.add(new person("张三",23)); list1.add(new person("李四",24)); list1.add(new person("赵八",28)); ArrayList<Student> list2=new ArrayList<>(); list2.add(new Student("六六",26)); list2.add(new Student("七七",27)); list1.addAll(list2); System.out.println(list1); } }
Foreach
public class demo1_Foreach { /* 增强for概述 * 简化数组和Collection集合的遍历 * 格式： * for（元素数据类型 变量: 数组或者Collection集合）{ * 使用变量即可，该变量就是元素 * }
* 增强for循环底层依赖的是迭代器（Iterator） * */ public static void main(String[] args) { int [] arr={1,2,3,4,5}; /*for (int i : arr) { System.out.println(i); }*/ for (int i : arr) { System.out.println(i); } ArrayList<String> list =new ArrayList<>(); list.add("a"); list.add("b"); list.add("c"); for (String string : list) { System.out.print(string); } } }
三种迭代
普通for循环，可以删除，但是要索引--
迭代器，可以删除，但是必须使用迭代器自身的remove方法，否则会出现并发修改异常
增强for循环不能删除
import java.util.ArrayList; import java.util.Iterator; public class demo2 { public static void main(String[] args) { ArrayList<String> list = new ArrayList<>(); list.add("a"); list.add("b"); list.add("b"); list.add("c"); list.add("d"); //1.普通for循环删除，索引要-- /*for (int i = 0; i < list.size(); i++) { if ("b".equals(list.get(i))) { list.remove(i--); //通过索引删除元素 } }*/ //2.迭代器删除 Iterator<String> it1=list.iterator(); while (it1.hasNext()) { if ("b".equals(it1.next())) { //list.remove("b"); //不能用集合的删除犯法，因为迭代器过程中如果修改会出现并发修改异常 //it1.remove(); } } for(Iterator<String> it2=list.iterator();it2.hasNext();){ if ("b".equals(it2.next())) { //list.remove("b"); //不能用集合的删除犯法，因为迭代器过程中如果修改会出现并发修改异常 //it2.remove(); } } //3.增强for循环 ,不能删除，只能遍历 for (String string : list) { if ("b".equals(string)) { list.remove("b"); } } System.out.println(list); } }
静态导入
格式：
import static 包名..，类名.方法名
注意事项
方法必须是静态的，如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀，由此可见，意义不太，所以一般不用
import static java.util.Arrays.sort; import javax.naming.ldap.SortControl; public class demo3_static { public static void main(String[] args) { int [] arr ={11,22,44,66,33,55}; sort(arr); //排序 //System.out.println(Arrays.toString(arr)); } public static sort(int [] arr){ } }
可变参数
定义方法的时候不知道该定义多少个数
格式：
修饰符 返回值类型 方法名 (数据类型... 变量名){ }
注意事项：
这里的变量其实是一个数组
如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个
public class demo4_ChangeableArgs { public static void main(String[] args) { int [] arr={11,22,33,44,55}; print(11,22,33,44,55); System.out.println("----------"); //print(); } /*public static void print(int [] arr){ for (int i : arr) { System.out.println(i); } }*/ public static void print(int x,int ... arr){ //可变参数是一个数组 for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } }
Arrays工具类的asList( )方法
import java.util.List; import java.util.ArrayList; import java.util.Arrays; public class demo5_AsList { //数组转换成集合,数组转换成集合虽然不能增加或减少元素，但是可以用集合的思想操作数组，也就是说可以使用其他集合中的方法 public static void main(String[] args) { //demo1(); //demo2(); //demo3(); //集合转数组，加泛型 ArrayList<String> list = new ArrayList<>(); list.add("a"); list.add("b"); list.add("c"); list.add("d"); String [] arr=list.toArray(new String [10]); //当集合转换数组时，数组长度如果小于等于集合的size时，转换后的数组长度等于集合的size //如果数组的长度大于了size，分配的数组长度就和你指定的长度一样 for (String string : arr) { System.out.println(string); } } public static void demo3() { Integer [] arr={11,22,33,44,55}; List<Integer> list=Arrays.asList(arr);//将数字转换成集合，数组必须是引用数据类型 System.out.println(list); } public static void demo2() { int [] arr={11,22,33,44,55}; List<int[]> list=Arrays.asList(arr); //基本数据类型的数组转换成集合，会将整个数组当做一个对象转换 System.out.println(list); } public static void demo1() { String [] arr={"a","b","c","d"}; List<String> list=Arrays.asList(arr); //将数字转换成集合 //list.add("f"); //不能添加 System.out.println(list); } }
集合嵌套ArrayList嵌套ArrayList
package tan.jung.jdk5; import java.util.ArrayList; import tan.jung.list.person; public class demo6_ArrayListArrayList { public static void main(String[] args) { ArrayList<ArrayList<person>> list =new ArrayList<>(); ArrayList<person> first = new ArrayList<>(); //创建第一个班级 first.add(new person("嘿嘿",18)); first.add(new person("嘻嘻",20)); first.add(new person("hh",22)); ArrayList<person> second = new ArrayList<>(); //创建第一个班级 second.add(new person("大力",19)); second.add(new person("美丽",21)); second.add(new person("ss",23)); //将班级天机到学科集合中 list.add(first); list.add(second); //遍历班级集合 for (ArrayList<person> a : list) { for (person person : a) { System.out.println(person); } } } }