一、数据结构
数据结构：一种数据存储的方式常见的数据结构：栈、队列、数组、链表、树、哈希表数据结构的特点： 栈：先进后出，后进先出 队列：先进先出 数组：有索引，查询快、增删慢list集合：数组元素有序，允许元素重复 ArrayList:底层数据结构是数组，查询快、增删慢。线程不安全，效率高 Vector:底层数据结构是数组，查询快、增删慢。线程安全，效率低 LinkedList:底层数据结构是链表，查询慢、增删快。线程不安全，效率高
二、泛型
泛型机制：JDK1.5之后引入的一个概念。把类型明确工作，推迟到创建对象，或调用方法时，才去明确的一种机制。泛型的语法：<数据类型,数据类型>泛型可以加在 接口上，类型，方法上泛型的好处：1.避免了向下转型，2.提高了代码的扩展性泛型的特点：泛型只在编译期有效，在运行期就擦除了
1.集合中使用泛型，可以明确本集合中应该添加何种数据类型
//在集合中使用泛型，可以明确本集合中应该添加何种数据类型
ArrayList<Integer> list1 = new ArrayList<Integer>();
list1.add(100);
list1.add(200);
list1.add(300);
ArrayList<String> list2= new ArrayList();
list2.add("aaaaa");
list2.add("bbbb");
list2.add("ccc");
list2.add("ddd");
//使用泛型，可以避免向下转型
ArrayList list3 = new ArrayList();
list3.add("aaaaa");
list3.add("bbbb");
list3.add("ccc");
list3.add("ddd");
Object obj = list2.get(0);
String string= (String) obj;
int length = string.length();
2.泛型有利用提高代码的扩展性
public static void main(String[] args) {
//泛型有利用提高代码的扩展性
MyObject myObject = new MyObject();
myObject.setObj(100);
Object obj = myObject.getObj();
Integer num= (Integer) obj;
System.out.println(num);
MyObject myObject1 = new MyObject();
myObject1.setObj("abc");
Object obj1 = myObject1.getObj();
String str= (String) obj1;
System.out.println(str.length());
}
public class MyObject {
private Object obj;
public Object getObj() {
return obj;
}
public void setObj(Object obj) {
this.obj = obj;
}
}
3.泛型可以加在类上
//泛型<T>定义在类上
public class MyClass<T> {
T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
}
public static void main(String[] args) {
MyClass<String> stringMyClass = new MyClass<>();
stringMyClass.setT("abc");
String t = stringMyClass.getT();
System.out.println(t);
MyClass<Integer> integerMyClass = new MyClass<>();
integerMyClass.setT(100);
Integer t1 = integerMyClass.getT();
System.out.println(t1);
}
4.泛型可以定义在接口上
public interface MyInterface<T,U,R>{
public R show(T t,U u);
}
//定义在接口上的泛型，可以在子类里面明确
public class MyTest implements MyInterface<String,Integer,Integer> {
public Integer show(String s,Integer integer){
return null;
}
}
5.将泛型定义在方法上
public class MyDemo {
// public void show(Integer a){
// System.out.println(a);
// }
// public void show(String a){
// System.out.println(a);
// }
// public void show(Object o){
// System.out.println(o);
// }
//将泛型定义在方法上，就是泛型方法
public<T> void show(T a){
System.out.println(a);
}
}
6.泛型统配符
泛型通配符<?>: 任意类型，如果没有明确，那么就是Object以及任意的Java类了? extends E: 向下限定，E及其子类? super E: 向上限定，E及其父类
public class MyTest2 {
public static void main(String[] args) {
//?泛型通配符
ArrayList<?> objects = new ArrayList<Cat>();
//向上限定<？ super Cat> 后面只能写该类本身，或该类的父类
ArrayList<? super Cat> objects1 = new ArrayList<Animal>();
//向下限定<? extends Animal> 后面只能写该类本身，或该类的子类
ArrayList<? extends Animal> objects2 = new ArrayList<Dog>();
}
}
class Animal{
}
class Cat extends Animal{
}
class Dog extends Animal{
}
三、增强for循环
public static void main(String[] args) {
//JDK1.5之后有一个循环的新语法
int[] arr={20,30,40,50};
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
//新式for循环遍历数组
//1.明确容器里的元素是什么数据类型
//2.容器的名字
//for(容器中元素的数据类型 当前遍历的元素名：容器名)
for(int ele:arr){
System.out.println(ele);
}
//采用新式for循环遍历数组
ArrayList<Integer> list= new ArrayList<>();
list.add(1004);
list.add(1000);
list.add(1002);
list.add(10026);
list.add(10077);
list.add(10089);
list.add(10000);
list.add(100444);
for(Integer ele:list){
System.out.println(ele);
}
}
并发修改异常ConcurrentModificationException
/*
我们在采用新式for循环遍历容器途中，如果你想要给容器中添加元素或删除元素，就会报并发修改异常
ConcurrentModificationException
for (Integer integer : list) {
if (integer.equals(1000)) {
list.add(10);
}
}*/
/*如果你要在遍历途中，要给容器添加元素或删除元素，你就使用普通for循环*/
for(int i=0;i<list.size();i++){
Integer integer = list.get(i);
if(integer.equals(1000)){
list.add(10);
}
}
四、可变参数
public static void main(String[] args) {
//JDK1.5之后提供的一个新语法，可变参数
//数据类型...参数名
//可变参数本质上是一个数组
int sum1 = getSum(11, 22, 33);
int sum2 = getSum(44, 55, 66);
System.out.println(sum1);
System.out.println(sum2);
}
public static int getSum(int... num){
int sum=0;
for (int i : num) {
sum+=i;
}
return sum;
}
//如果一个方法，有多个参数，那么可变参数，就位于最后一个
public static int show(int b,int ...num){
return 0;
}
五、集合与数组的相互转换
把集合转换成数组
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(1004);
list.add(1000);
list.add(1002);
list.add(10026);
list.add(10077);
list.add(10089);
list.add(10000);
list.add(100444);
Object[] objects = list.toArray();
System.out.println(Arrays.toString(objects));
}
把数组转化成集合
int[] arr={20,30,40,50,60,70};
List<int[]> ints = Arrays.asList(arr);
//注意事项：通过asList转换过来的集合，该集合就不能再次添加元素或删除元素
//只能获取元素来用
