标签：Java list1 System add 初学 day13 println public out

day 13

数据结构

1、栈

栈：入口和出口是一个反向，且取出的顺序是先进后出。数据进入栈中叫入栈也叫压栈，数据从栈中被取出叫出栈也叫弹栈

栈数据结构的特点：先进后出

场景：

将A，B，C按顺序存入栈中并取出

存储的顺序：ABC
取出的顺序：CBA

2、队列

队列： 入口和出口是反方向的，且取出的顺序是先进先出。数据存入队列叫入队，将数据从队列中取出叫出队。

队列数据结构的特点： 先进先出

场景：

将A，B，C按顺序存入队列中并取出

存储的顺序：ABC
取出的顺序：ABC

3、数组

数组： 是一块连续固定大小的内存空间，并且有着索引的概念。

数组数据结构的特点： 查询快，增删慢。

场景： 现在有一个长度为5大小的数组，存储了11，22，33，44，55元素

需求1：在33和44元素之间添加一个新的元素66

/*
1、创建一个新的数组，长度为原来的+1
2、遍历旧数组，从索引0开始遍历，直到33截至，将旧数组的元素添加至新数组中
3、将新的元素66添加到新的数组中
4、继续遍历旧数组，将剩下的元素添加到新数组中
*/


import java.util.Arrays;
public class test1 {
    public static void main(String[] args) {
        int[] oldarr = {11,22,33,44,55};
        System.out.println(Arrays.toString(oldarr));
        System.out.println("======================================");
        int[] newarr = new int[oldarr.length+1];
        for(int i=0;i<3;i++){
            newarr[i]=oldarr[i];
        }
        newarr[3]=66;
        for (int i=3;i< oldarr.length;i++){
            newarr[i+1]= oldarr[i];
        }
        System.out.println(Arrays.toString(newarr));
    }
}

需求2：将旧数组中33这个元素删除

/*
1、创建一个新数组，长度为原来的-1
2、遍历旧数组，从索引0开始，到33元素之前截止，将元素添加到新数组中
3、跳过33元素，将后续元素添加到新数组中
*/

需求3：获取33元素

/*
直接通过索引2获取
*/

4、链表

链表：是在内存中可以不连续的空间，且每个元素是一个独的空间。

链表的特点：增删快，查询慢

场景：现在需要将11，22，33，44，55元素使用链表存储起来

需求1：在33，44元素之间添加一个新的元素66

/*
1、66元素之间也需要封装成一个内存空间
2、将33元素指针域的值使用tmp存储
3、在33元素的指针域上创建一个66的空间，将地址值赋值给33指针域、
4、再将tmp的赋值给66指针域
*/

需求2：将33元素从链表中删除

/*
1、将33元素的指针域赋值给22元素的指针域
2、将33指针域的值赋值为null
*/

需求3：查询元素44

/*
从头开始遍历
*/

拓展知识

1、如果链表中的一个节点由两个指针域与一个数据域构成的话，这样的链表称之为双链表或者双向链表

2、如果将第一个元素的地址值赋值给最后一个元素的指针域，那么将成为一个新的链表，称之为循环链表

3、我们今后使用链表的情况不多，一般会与数组一起使用

5、哈希表

哈希表：是由Hashtable + 哈希函数构成的

Hashtable可以看作一个特殊作用的数组

哈希函数主要是用于计算元素要在Hashtable中存储的位置

需求：统计一下若干个数【0~9】中，每个数出现的次数
2，3，4，5，2，5，7，8，9，7，6，4，5，2，6，7

0	0	0	0	0	0	0	0	0	0
0	1	2	3	4	5	6	7	8	9

哈希函数原则上是完全可以自定义的，常用的方案拿着元素的整数形式%len(Hashtable)=>索引位置

我们以后开发中，常见的数据，不止有数字，还会有字符串，对象，数组，音频，视频等各种各样的数据需要进行存储我们以后遇到非数字的数据的时候，会先将其转变成数字的形式，再进行取余计算。一般情况下是取对应数据的哈希值

hash(数据)%len(Hashtable)[....]=>索引位置
"hello”->168 % len(Hashtable)=>存储位置1
“world”->573 % len(Hashtable)=>存储位置2

6、ArrayList

ArrayList：是Collection集合下的一个子接口List接口下的一个具体的类。

特点：底层数据结构是数组，查询快，增删慢，线程不安全，效率高。

Collection[接口]:
    List[接口]: 元素有序，可以发生重复，有索引的概念
        ArrayList[具体的子类]: 底层数据结构是数组，查询快，增删慢，线程不安全，效率高。

    Set[接口]: 元素无序且唯一，没有索引

public class ArrayListDemo1 {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList list1 = new ArrayList();

        //创建元素对象
        //将元素添加到集合中
        list1.add("hello");
        list1.add("world");
        list1.add("java");
        list1.add("hadoop");
        list1.add("hello");
        list1.add("world");

        //遍历集合
        //1. 转数组遍历
        Object[] objects = list1.toArray();
        for(int i=0;i<objects.length;i++){
            System.out.println(objects[i]);
        }
        System.out.println("========================");

        //2. 使用迭代器的方式遍历
        Iterator iterator = list1.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("========================");

        //3. 使用size()和get(i) 只有List集合才拥有的遍历方式
        for(int i=0;i<list1.size();i++){
            System.out.println(list1.get(i));
        }

    }
}

**习题： **去除集合中字符串的重复值(字符串的内容相同)

public class ArrayListTest1 {
    public static void main(String[] args) {
        ArrayList list1 = new ArrayList();

        //创建元素对象
        //将元素添加到集合中
        list1.add("hello");
        list1.add("world");
        list1.add("java");
        list1.add("hadoop");
        list1.add("hello");
        list1.add("world");
        System.out.println("list1: " + list1);
        System.out.println("-----------------------------");

        //创建一个新的集合
        ArrayList list2 = new ArrayList();

        for (int i = 0; i < list1.size(); i++) {
            String str = (String) list1.get(i);
            if (!list2.contains(str)) {
                list2.add(str);
            }
        }

        System.out.println("list2: " + list2);
    }
}

当去重的对象是我们自定义的对象时

去除集合中自定义对象的重复值(对象的成员变量值都相同)
我们按照实现去重字符串的逻辑去重自定义对象，发现自定义对象并没有去重
我们要去看contains的源码，底层判断元素是否存在新集合的逻辑是：
挨个使用待插入的元素与新集合中的元素使用equals方法比较，我们元素Student类中并没有重写equals方法
所以使用的是父类Object中的equals方法，而父类Object中的equals方法比较的是地址值
又因为每一个学生都是new出来的，所以地址值都不一样，比较的结果永远为false
要想比较内容值，需要元素类型重写equals方法，自动生成即可

public class ArrayListTest2 {
    public static void main(String[] args) {
        ArrayList list1 = new ArrayList();

        Student s1 = new Student("李刚", 15);
        Student s2 = new Student("钱志强", 16);
        Student s3 = new Student("江川", 30);
        Student s4 = new Student("李刚", 15);
        Student s5 = new Student("祝帅", 15);

        list1.add(s1);
        list1.add(s2);
        list1.add(s3);
        list1.add(s4);
        list1.add(s5);
        System.out.println("list1: " + list1);

        System.out.println("=================================");
        ArrayList list2 = new ArrayList();

        for(int i=0;i<list1.size();i++){
            Student s = (Student) list1.get(i);

            /*
                //Student s1 = new Student("李刚", 15);
                public boolean contains(Object o) {
                    return indexOf(o) >= 0;
                }

                public int indexOf(Object o) {
                    if (o == null) {
                        for (int i = 0; i < size; i++)
                            if (elementData[i]==null)
                                return i;
                    } else {
                        for (int i = 0; i < size; i++)
                            if (o.equals(elementData[i]))
                                return i;
                    }
                    return -1;
                }
             */

            if(!list2.contains(s)){
                list2.add(s);
            }
        }
        System.out.println("list2: " + list2);

    }
}





import java.util.Objects;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = 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;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }


    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

7、Vector

Vector：是List接口下的具体的类【用法与ArrayList相近，但是ArrayList是线程安全的】

特点：底层数据结构是数组，查询快，增删慢，先出安全，效率低。【即使线程安全，但是我们以后可能还是不会使用，而是使用将ArrayList变成线程安全的方法】

特殊的功能：

public void addElement(E obj)  //向集合中添加元素,效果和add方法一模一样，可以使用add方法替代
public E elementAt(int index)  //根据索引获取元素,效果和get方法一模一样，可以使用get方法替代
public Enumeration elements()  //效果和迭代器方法一模一样，可以使用迭代器方法替代

public class VectorDemo1 {
    public static void main(String[] args) {
        //创建Vector集合对象
        Vector v1 = new Vector();

        //创建元素并添加元素
        v1.add("hello");
        v1.add("world");
        v1.add("java");
        v1.add("hadoop");
        v1.add("hbase");
        v1.add("java");
        v1.add("hello");


        System.out.println("v1: "+v1);
        System.out.println("-------------------------------");
        //public void addElement(Object obj)  向集合中添加元素
//        v1.addElement("flink");
//        System.out.println("v1: "+v1); // 效果和add方法一模一样，可以使用add方法替代

        //public Object elementAt(int index) 根据索引获取元素
//        System.out.println(v1.elementAt(2));// 效果和get方法一模一样，可以使用get方法替代
//        System.out.println(v1.get(2));

        //public Enumeration elements()
//        Enumeration elements = v1.elements();// 效果和迭代器方法一模一样，可以使用迭代器方法替代
//        while (elements.hasMoreElements()){
//            System.out.println(elements.nextElement());
//        }


    }
}

8、LinkedList

LinkedList:是List接口下的具体的类

特点：底层数据结构是双链表，增删快，查询慢，线程不安全，效率高

特殊功能：

public void addFirst(E e)及addLast(E e)         //在第一位或者最后一位添加元素
public E getFirst()及getLast()				   //获取第一位或者最后一位的元素				
public E removeFirst()及public E removeLast()   //删除第一位或者最后一位的元素

public class LinkedListDemo1 {
    public static void main(String[] args) {
        LinkedList list1 = new LinkedList();

        list1.add("hello");
        list1.add("world");
        list1.add("java");
        list1.add("hello");
        list1.add("world");
        list1.add("hadoop");

        System.out.println("list1: "+list1);
        System.out.println("=====================");
        //public void addFirst(E e)及addLast(E e)
        list1.addFirst("李刚");
        list1.addLast("钱志强");
        System.out.println("list1: "+list1);
        System.out.println("----------------------");
        //public Object getFirst()及getLast()
        System.out.println(list1.getFirst());
        System.out.println(list1.getLast());
        System.out.println("list1: "+list1);
        System.out.println("----------------------");
        //public E removeFirst()及public E removeLast()
        System.out.println(list1.removeFirst());
        System.out.println(list1.removeLast());
        System.out.println("list1: "+list1);


    }
}

面试题：

    请用LinkedList模拟栈数据结构的集合，并测试

    题目的本意是，自己写一个类，底层封装了LinkedList，创建这个类，把这个类当作集合类去用。

import java.util.LinkedList;
public class MyStack {
    private LinkedList linkedList;

    MyStack() {
        linkedList = new LinkedList();
    }

    public void addYuanSu(Object object){
        linkedList.addFirst(object);
    }

    public Object getYuanSu(){
        return linkedList.removeFirst();
    }

    public int getlength(){
        return linkedList.size();
    }

    @Override
    public String toString() {
        return "MyStack{" +
                "linkedList=" + linkedList +
                '}';
    }
}





public class LinkedListDemo1 {
    public static void main(String[] args) {
        MyStack myStack = new MyStack();

        myStack.addYuanSu("A");
        myStack.addYuanSu("B");
        myStack.addYuanSu("C");
        myStack.addYuanSu("D");
        myStack.addYuanSu("E");

        System.out.println(myStack);

        int length  = myStack.getlength();

        System.out.println("=====================");
        System.out.println(length);
        for (int i = 0;i<length;i++){
            System.out.println(myStack.getYuanSu());
        }
    }
}

9、泛型

泛型：泛型是将来用于接收一个引用数据类型的，相当于一个参数

/*既然是参数，就需要符合标识符的命名规则

一般情况下，使用一个或多个大写字母表示
*/


public class Demo<W> {
    public void fun1(W w) {
        System.out.println("接收到的参数是：" + w);
    }
}

class Test1{
    public static void main(String[] args) {
//        Demo demo = new Demo();
//        demo.fun1("hello");
//        demo.fun1(10);
//        demo.fun1(12.34);


        Demo<String> d1 = new Demo<>();
        d1.fun1("hello");
//        d1.fun1(10);

    }
}

泛型方法

public class Demo1 {
    //泛型方法
    public <Q> void fun1(Q q) {
        System.out.println("接收到的参数是：" + q);
    }

    //普通的方法
    public void fun2(Object obj) {
        System.out.println("接收到的参数是：" + obj);
    }
}

class Test2{
    public static void main(String[] args) {
        Demo1 demo1 = new Demo1();
        demo1.fun1("hello");
        demo1.fun1(100);
    }
}

泛型接口

public interface Inter1<P> {
    void show1(P p);
}

class Inter1Impl<P> implements Inter1<P> {

    @Override
    public void show1(P p) {
        System.out.println("接收到参数值是：" + p);
    }
}

class Test3{
    public static void main(String[] args) {
        Inter1Impl<String> stringInter1 = new Inter1Impl<>();
        stringInter1.show1("hello");
//        stringInter1.show1(123);
    }
}

泛型通配符

型通配符
    <?>
任意类型，如果没有明确，那么就是Object以及任意的Java类了
    ? extends E
向下限定，E及其子类
    ? super E
向上限定，E及其父类

class Demo5{
    public void show1(Collection<?> c1){ // 表示可以传入一个Collection集合，元素的类型是任意引用数据类型
        System.out.println("任意类型泛型通配符");
    }

    // 表示可以传入一个Collection集合，元素的类型是Animal或Animal子类的类型
    public void show2(Collection<? extends Animal> c1){
        System.out.println("? extends Animal类型泛型通配符");
    }

    // 表示可以传入一个Collection集合，元素的类型是Dog或Dog父类的类型
    public void show3(Collection<? super Dog> c1){
        System.out.println("任意类型泛型通配符");
    }
}

public class Demo4 {
    public static void main(String[] args) {
        Demo5 demo5 = new Demo5();

        ArrayList<Object> list1 = new ArrayList<>();
        ArrayList<Animal> list2 = new ArrayList<>();
        ArrayList<Dog> list3 = new ArrayList<>();
        ArrayList<Cat> list4 = new ArrayList<>();


//        demo5.show1(list1);
//        demo5.show1(list2);
//        demo5.show1(list3);
//        demo5.show1(list4);

//        demo5.show2(list1); // 不行
//        demo5.show2(list2);
//        demo5.show2(list3);
//        demo5.show2(list4);

//        demo5.show3(list1);
//        demo5.show3(list2);
//        demo5.show3(list3);
//        demo5.show3(list4); // 不行


    }
}


public class Animal {
}

class Dog extends Animal {

}

class Cat extends Animal {

}

标签：Java,list1,System,add,初学,day13,println,public,out
From： https://www.cnblogs.com/qianzhiqiang798/p/18475028

Java 初学 day13