丶嘟嘟
丶嘟嘟

集合与泛型

一、复习回顾

问：集合分为两大类？

Collection：存储一组对象
Map：存储一组键值对(key,value)，键值对又称为映射关系。

问：Collection有Set和List等子接口，那么Set和List有啥区别？

List：有序（可以按照索引操作），可重复
Set：无序（不能按照索引操作），不可重复

问：Set有一些常见的实现类，它们是谁？

HashSet：散列无规律
LinkedHashSet：按照元素添加的顺序排列
TreeSet：按照元素的大小顺序排列

问：Set的实现类有什么区别？

关于底层，后面讲Map再细说

集合与泛型_第1张图片

问：Collection接口的一些方法？

1、添加

  • add(E e)：添加一个元素
  • addAll(Collection c)：添加一组对象。集合1.addAll(集合2)，将集合2的元素添加到集合1中，谁.影响谁里面的元素。集合1变成两个集合的并集。

集合与泛型_第2张图片

2、删除

  • clear()：清空
  • remove(Object e)：删除一个对象
  • removeAll(Collection c)：删除一组对象，删除两个集合的交集。集合1.removeAll(集合2)，删除的是集合1中的元素，谁.删谁里面的元素。
  • retainAll(Collection c)：删除一组对象，删除两个集合的非交集部分，留下两个集合的交集部分。集合1.removeAll(集合2)，删除的是集合1中的元素，谁.删谁里面的元素。
  • removeIf(Predicate p)：删除一组对象。重写Predicate 接口中的test方法，当test方法判断该元素返回true，这个元素就会被删除。

3、查询/查看

  • boolean contains(Object obj)：判断某个对象是不是在当前集合中
  • boolean containsAll(Collection c)：判断c集合中的所有元素是不是都在当前集合中，即判断c集合是不是当前集合的子集。
  • boolean isEmpty()：是否为空
  • int size()：元素个数
  • Object[] toArray()：把元素放到数组中

4、遍历方式

  • 增强foreach循环（它底层也是使用迭代器）
  • Iterator迭代器
    • Iterator iterator()

问：Iterator迭代器遍历用的方法？

  • boolean hasNext()：判断迭代器当前位置是不是还有元素可迭代
  • Object next()：先返回迭代器当前位置的元素，然后迭代器向下一个元素移动。

问：迭代器在遍历集合元素的过程中，切记不要做哪些事？

不要对当前集合调用集合的add，remove等方法，进行元素个数的修改。

问：如果迭代器要删除元素，应该调用谁的什么方法？

调用迭代器的remove方法。

问：foreach里面能不能调用当前集合的add，remove等方法？能不能调用迭代器的remove方法？

不能。

不能。

结论：foreach里面，针对当前集合的add,remove等都是无法操作。

问：List接口的一些方法？

除了从Collection接口继承的方法之外，List还扩展了哪些方法？

1、添加

add(int index, Object obj)：指定位置添加一个元素。

addAll(int index, Collection c)：指定位置添加一组元素。

2、删除

remove(int index)：删除指定位置的元素。

3、查询

Object get(int index)：返回index位置的元素

List subList(int start, int end)：截取[start, end)位置的一组元素

int indexOf(Object obj)：返回首次出现的索引值。不存在返回-1。

int lastIndexOf(Object obj)：返回末次出现的索引值。不存在返回-1。

4、修改

set(int index, Object obj)：替换[index]位置的元素

replaceAll(UnarayOperator u)：要重写UnarayOperator 接口的apply方法，方法的参数是元素的原值，方法的返回值是元素的新值。

问：hashCode和equals方法

  • boolean equals(Object obj)：比较两个对象是不是相等。怎么比较？

    • 如果重写了，通常是比较两个对象的内容/属性值
    • 如果没有重写，Object类中定义的equals方法是比较对象的地址值

  • int hashCode()：计算对象的身份证号

    • 通常该值用于计算对象在HashSet，HashMap等与哈希有关的集合中的存储位置

hashCode方法重写有一些要求？

  • 和重写equals方法选择的属性一样（快捷键Alt + insert）
  • 同一个对象，属性值不变的话，调几次它们的hashCode值应该相同
  • 如果equals返回true，即相同，要求它们的hashCode值也相同
  • 如果equals返回false，即不同，它们的hashCode值可能相同，也可能不同。当然是最好是不同。
  • 如果两个对象的hashCode值不同，两个对象equals一定是false，即不同。

重写equals方法有什么要求吗？

  • 自反性：x.equals(x)一定是true
  • 一致性：如果x和y两个对象的属性没有变化，多次调用x.equals(y)返回的结果要一致
  • 传递性：x.equals(y)相同，y.equals(z)也相同，那么应该得出x.equals(z)也相同
  • 对称性：x.equals(y)相同，反过来，y.equals(x)也相同，或者x.equals(y)不同，反过来，y.equals(x)也不同
  • 非空对象与null比较一定是false：x!=null，那么x.equals(null)一定是false
package com.atguigu.list;

import org.junit.Test;

public class TestEmployee {
    @Test
    public void test1()throws Exception{
        //手动重写equals或hashCode方法的问题，这里只演示equals方法。
        //需求：如下3个对象，我希望比较equals都相同
        Employee e1 = new Employee(1,"张三","男");//编号，姓名，性别
        Employee e2 = new Employee(1,"张三","man");
        Employee e3 = new Employee(1,"张三","Man");

        System.out.println(e1.equals(e2));
        System.out.println(e1.equals(e3));
        System.out.println(e2.equals(e3));

        System.out.println(e1);
        System.out.println(e2);
        System.out.println(e3);
    }
}


package com.atguigu.list;

import java.util.Objects;

public class Employee {
    private int id;
    private String name;
    private String gender;

    public Employee(int id, String name, String gender) {
        this.id = id;
        this.name = name;
        this.gender = gender;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Employee employee = (Employee) o;

        if (id != employee.id) return false;
        if (!Objects.equals(name, employee.name)) return false;
//        return Objects.equals(gender, employee.gender);
        return equalsGender(gender, employee.gender);
    }

    private boolean equalsGender(String gender1, String gender2){
        if(gender1 == gender2){
            return true;
        }
        if(gender1!=null && gender1.equals("男")){
            gender1 = "man";
        }
        if(gender2!=null && gender2.equals("男")){
            gender2 ="man";
        }
        return gender1.equalsIgnoreCase(gender2);//不区分大小写比较两个单词
    }

    @Override
    public int hashCode() {
        int result = id;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        result = 31 * result + (gender != null ? gender.hashCode() : 0);
        return result;
    }
}

二、ListIterator

2.1 ListIterator是什么

ListIterator也是一种迭代器，它是Iterator接口的子接口，而且是专门用于List系列的集合的迭代器。

2.2 ListIterator的对象如何获取

List系列的集合.listIterator()可以获取ListIterator的对象。一开始迭代器在[0]位置。

List系列的集合.listIterator(int index)也可以获取ListIterator的对象。一开始迭代器在[index]位置。

2.3 API方法

Iterator接口有的方法，ListIterator也有。（因为会继承过来）

ListIterator接口又扩展了一些方法：

  • 获取元素的下标

    • int nextIndex()
    • int previousIndex()

  • 遍历的方向

    • 除了 hasNext() + next() 可以实现从左往右遍历
    • 还可以用下面两个方法实现从右往左遍历
      • boolean hasPrevious()
      • Object previous()

  • 支持的操作

    • 除了remove()（这是迭代器的remove)之外
    • 还增加了迭代过程中的如下方法，它们是迭代器的add和set
      • add(Object obj)
      • set(Object obj)

2.4 演示代码

package com.atguigu.list;

import org.junit.Test;

import java.util.ArrayList;
import java.util.ListIterator;

public class TestListIterator {
    @Test
    public void test1()throws Exception{
        ArrayList list = new ArrayList();
        list.add("hello");
        list.add("world");
        list.add("java");

        ListIterator listIterator = list.listIterator();//返回的是ListIterator接口的实现类的对象
        //从左往右遍历
        while(listIterator.hasNext()){
            int index = listIterator.nextIndex();//迭代器当前指向的元素的下标
            int preIndex = listIterator.previousIndex();
            Object obj = listIterator.next();
            System.out.println("前一个元素的下标：" + preIndex);
            System.out.println("当前元素下标：" + index + ":" + obj);
        }
    }

    @Test
    public void test2()throws Exception{
        ArrayList list = new ArrayList();
        list.add("hello");
        list.add("world");
        list.add("java");

//        ListIterator listIterator = list.listIterator();//迭代器一开始在[0]位置
        ListIterator listIterator = list.listIterator(list.size());//迭代器一开始在[list.size()]位置
        //这里size=3，迭代器在[3]的位置
        //从右往左遍历
        while(listIterator.hasPrevious()){
            int index = listIterator.previousIndex();
            Object obj = listIterator.previous();
            System.out.println("前一个元素的下标：" + index);
            System.out.println("前一个元素：" + obj);
        }
    }

    @Test
    public void test3()throws Exception{
        ArrayList list = new ArrayList();
        list.add("hello");
        list.add("world");
        list.add("java");

        //需求：在hello后面添加一个atguigu
        /*
        方式一：不用迭代器
         */
        /*int index = list.indexOf("hello");//查询hello的位置
        list.add(index + 1,"atguigu");//在hello的后面添加新元素atguigu
        System.out.println(list);*/

        /*
        方式二：使用ListIterator迭代器
         */
        ListIterator listIterator = list.listIterator();
        while(listIterator.hasNext()){
            Object obj = listIterator.next();
            if("hello".equals(obj)){
                listIterator.add("atguigu");
            }
        }
        System.out.println(list);
    }

    @Test
    public void test4()throws Exception {
        ArrayList list = new ArrayList();
        list.add("hello");
        list.add("haha");
        list.add("world");
        list.add("java");

        //需求：在hello的前面添加atguigu
        /*
        方式一：不用迭代器
         */
       /* int index = list.indexOf("hello");//查询hello的位置
        list.add(index ,"atguigu");//在hello的前面添加新元素atguigu，插入到hello原来的位置，然后自动把hello及其后面的元素右移
        System.out.println(list);*/

        /*
        方式二：使用ListIterator迭代器
         */
        ListIterator listIterator = list.listIterator(list.size());
        while(listIterator.hasPrevious()){
            Object obj = listIterator.previous();
            if("hello".equals(obj)){
                listIterator.add("atguigu");
            }
        }
        System.out.println(list);
    }

    @Test
    public void test5()throws Exception{
        ArrayList list = new ArrayList();
        list.add("hello");
        list.add("haha");
        list.add("world");
        list.add("java");
        //Hello,Haha,World,Java

        //需求：把所有单词的首字母改为大写
        ListIterator listIterator = list.listIterator();
        while(listIterator.hasNext()){
            Object obj = listIterator.next();
            String str = (String) obj;

            char first = str.charAt(0);
            first = Character.toUpperCase(first);
            String after = str.substring(1);//从[1]到最后
            listIterator.set(first + after);//替换原来的元素
        }
        System.out.println(list);

    }
}

三、List接口的常用实现类

3.1 实现类有哪些？

  • ArrayList（最常用）：动态数组
  • Vector：动态数组
  • LinkedList：双向链表
  • Stack：栈

3.2 ArrayList和Vector的区别

集合与泛型_第3张图片

3.3 动态数组与双向链表的区别

详细请看

集合与泛型_第4张图片

3.4 栈等数据结构3

3.4.1 栈、队列、双端队列

集合与泛型_第5张图片

集合与泛型_第6张图片

3.4.2 Queue队列接口

集合与泛型_第7张图片

3.4.2 Deque双端队列接口

集合与泛型_第8张图片

3.4.3 演示代码

package com.atguigu.list;

import org.junit.Test;

import java.util.*;

public class TestListImpl {
    @Test
    public void test1()throws Exception{
        //演示栈类型Stack
        Stack stack = new Stack();
        //它自己扩展的方法，为了体现它和列表的不同，突然栈的特点
        stack.push("hello");//压栈
        stack.push("world");
        stack.push("java");

        System.out.println(stack.pop());//弹出栈  java
        System.out.println(stack.pop());//world
        System.out.println(stack.pop());//hello
        System.out.println(stack.pop());//java.util.EmptyStackException 空栈异常
    }

    @Test
    public void test2()throws Exception {
        //演示栈类型Stack
        Stack stack = new Stack();
        //它自己扩展的方法，为了体现它和列表的不同，突然栈的特点
        stack.push("hello");//压栈
        stack.push("world");
        stack.push("java");

        while(!stack.empty()){//非空判断
            System.out.println(stack.pop());
        }
    }

    @Test
    public void test3()throws Exception{
        //演示栈类型Stack
        Stack stack = new Stack();
        //它自己扩展的方法，为了体现它和列表的不同，突然栈的特点
        stack.push("hello");//压栈
        stack.push("world");
        stack.push("java");

        System.out.println(stack.peek());//peek偷偷看一眼，现在栈顶是谁，不敢拿
        System.out.println(stack.peek());
        System.out.println(stack.peek());
        System.out.println(stack.peek());
    }

    @Test
    public void test4()throws Exception{
        //演示ArrayList  用作栈使用
        ArrayList list = new ArrayList();
        //关键点：要实现先进后出的效果
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("atguigu");

        //出来的顺序：atguigu,java,world,hello   取走
        while(list.size()>0){//有元素可取
            System.out.println(list.remove(list.size()-1));
            //list.size()-1是列表中最后一个元素的索引
        }

        System.out.println(list);//空的
    }

    @Test
    public void test5()throws Exception{
        //演示Queue接口的使用
        Queue queue = new LinkedList();//这么写是希望大家知道它们的关系
        queue.add("hello");
        queue.add("world");
        queue.add("java");
        queue.add("atguigu");

        //出来的顺序：hello,world,java,atguigu

        System.out.println(queue.element());//hello  偷偷查看第一个元素，队头，谁带头
        System.out.println(queue.element());//hello
        System.out.println(queue.element());//hello

        //关键点：先进先出
        while(!queue.isEmpty()){//非空判断
            System.out.println(queue.remove());
        }
        System.out.println(queue);//空的
    }


    @Test
    public void test6()throws Exception{
        Queue queue = new LinkedList();
//        System.out.println(queue.element());//java.util.NoSuchElementException
        System.out.println(queue.remove());//java.util.NoSuchElementException
    }

    @Test
    public void test7()throws Exception{
        Queue queue = new LinkedList();
        System.out.println(queue.peek());//null
        System.out.println(queue.poll());//null
    }

    @Test
    public void test8()throws Exception{

        //双端队列
        Deque deque = new LinkedList();
        //关键词：两头都可以进、出
        deque.addFirst("hello");
        deque.addLast("world");
        deque.addFirst("world");
        deque.addFirst("atguigu");
        deque.addLast("chai");
        //顺序：左边是first的话   atguigu,world,hello,world,chai
        System.out.println(deque);

        System.out.println(deque.removeLast());//chai
        System.out.println(deque.removeFirst());//atguigu

    }

}

四、Collection系列集合关系图

集合与泛型_第9张图片

五、泛型

5.1 什么是泛型？

泛型：泛指某个类型，代码中看到、、等都是和泛型有关的。

5.2 泛型的好处

JDK1.5引入的泛型。

为了解决：

  • 避免类型的转换，主要是向下转型
  • 把很多场景的类型检查从运行时提前到编译时

泛型带来的好处：

  • 简化了代码：通过减少向下转型
  • 更安全：编译时就已经进行类型检查
package com.atguigu.generic;

import org.junit.Test;

import java.util.ArrayList;

public class TestGeneric {
    @Test
    public void test1NoGeneric()throws Exception{
        ArrayList list = new ArrayList();
        list.add("hello");
        list.add("java");
        list.add("world");
        list.add("atguigu");
        //需求：输出元素，并且求字符串元素的长度
        for (Object o : list) {
            String str = (String) o;
            System.out.println(str+"的长度：" + str.length());
        }
    }

    @Test
    public void test1UseGeneric()throws Exception{
        ArrayList<String> list = new ArrayList<String>();
        list.add("hello");
        list.add("java");
        list.add("world");
        list.add("atguigu");

        //快捷键iter
        for (String str : list) {//避免的向下转型
            System.out.println(str+"的长度：" + str.length());
        }
    }

    @Test
    public void test2NoGeneric()throws Exception{
        //给list添加元素，但是只能添加String，不能添加其他类型的对象
        ArrayList list = new ArrayList();
        list.add("hello");
        list.add("java");
        list.add("world");
        list.add(1);//编译器不给提示，它不满足我们的要求
        for (Object o : list) {
            if(o instanceof String) {
                String str = (String) o;
                System.out.println(str + "的长度：" + str.length());
            }
        }
    }

    @Test
    public void test2UseGeneric()throws Exception{
        //给list添加元素，但是只能添加String，不能添加其他类型的对象
        ArrayList<String> list = new ArrayList<String>();
        list.add("hello");
        list.add("java");
        list.add("world");
//        list.add(1);//编译器立刻给出提示，它不满足我们的要求
    }
}

5.3 泛型的使用场景有哪些？

泛型可以在两个位置定义和使用？

  • 在类或接口名后面定义和使用泛型，这样的类或接口称为泛型类或泛型接口
  • 在方法的返回值类型的前面定义泛型，在当前方法中使用泛型，这样的方法称为泛型方法

5.4 泛型类或泛型接口

5.4.1 回忆之前学习的类或接口

java.lang.Comparable：自然比较接口，它有一个抽象方法：int compareTo(T o)，这里的T代表要比较大小的对象类型，T代表Type

java.util.Comparator：定制比较器接口，它也有一个抽象方法：int compare(T o1,T o2) ，这里的T代表要比较大小的对象类型

java.util.Collection：Collection集合根接口，这里的E代表的是集合元素的类型，E代表element元素

java.util.List、Set、Queue、Deque等子接口。

java.lang.Iterable：可迭代的接口

java.util.Iterator：迭代器接口

java.util.ArrayList、Vector、LinkedList、Stack：List系列集合类型

java.util.HashSet、LinkedHashSet、TreeSet：Set系列集合的类型。

5.4.2 如何使用一个泛型类或泛型接口？

如果一个类或接口名后面声明（定义）了泛型，那么使用该类或接口时，最好指定该泛型的具体类型，否则会有警告。

注意：

  • 为泛型指定具体类型时，必须指定为引用数据类型。不支持基本数据类型。

1、演示泛型类的使用

package com.atguigu.generic;

import org.junit.Test;

import java.util.ArrayList;

public class TestUseGenericClass {
    @Test
    public void test1()throws Exception{
        //ArrayList，这里代表的是元素的类型
        //存储整数
//        ArrayList list = new ArrayList();//不支持基本数据类型
        ArrayList<Integer> list = new ArrayList<Integer>();//只支持基本数据类型
        list.add(1);
//        list.add(1.0);//报错，它们都不能自动转为Integer对象
//        list.add("hello");//报错，它们都不能自动转为Integer对象
    }
    
    @Test
    public void test2()throws Exception{
        //存储小数
        ArrayList<Double> list = new ArrayList<Double>();
//        list.add(1);//错误，1是int类型，它可以自动转为double（自动类型提升），但是不能自动转为Double（自动装箱）
        list.add(1.0);
        list.add((double)1);
        list.add(1d);//在数字后面加d或D表示double
    }
}

2、演示泛型接口的使用

（1）Comparable

集合与泛型_第10张图片

package com.atguigu.generic;

/*
需求：要求员工类Employee实现Comparable接口
        T是Type单词的缩写，是要比较大小的对象的类型，
        这里是两个员工对象要比较大小，T是Employee类型

    员工对象默认按照id比较大小
 */
public class Employee implements Comparable<Employee>{
    private int id;
    private String name;
    private double salary;

    public Employee() {
    }

    public Employee(int id, String name, double salary) {
        this.id = id;
        this.name = name;
        this.salary = salary;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", salary=" + salary +
                '}';
    }

    @Override
    public int compareTo(Employee o) {
        return id - o.id;
    }
}
（2）Comparator
package com.atguigu.generic;

import java.util.Comparator;

/*
需求：定制一个比较器，用于比较两个员工对象的大小，
   要求：先按照薪资比较大小，如果薪资相同，再按照编号比较大小

   实现Comparator接口，这里的T代表要比较大小的对象的类型，这里是员工类
 */
public class EmployeeSalaryComparator implements Comparator<Employee> {
    @Override
    public int compare(Employee o1, Employee o2) {

//       return o1.getSalary() - o2.getSalary();//double - double，结果是double，返回值类型是int
//       return (int)(o1.getSalary() - o2.getSalary());//语法上没毛病，  15000.56  15000.42 看业务层面是否允许这样误差

/*        if(o1.getSalary() > o2.getSalary()){
            return 1;
        }else if(o1.getSalary() < o2.getSalary()){
            return -1;
        }else{
            return o1.getId() - o2.getId();
        }*/

        int result = Double.compare(o1.getSalary(), o2.getSalary());
        //如果o1.getSalary() 大于  o2.getSalary()，该方法结果返回正整数
        //如果o1.getSalary() 小于  o2.getSalary()，该方法结果返回负整数
        //如果o1.getSalary() 等于  o2.getSalary()，该方法结果返回零
        /*
        Integer.compare(o1.getId(),o2.getId())比较两个int值，
        //如果o1.getId() 大于  o2.getId()，该方法结果返回正整数
        //如果o1.getId() 小于  o2.getId()，该方法结果返回负整数
        //如果o1.getId() 等于  o2.getId()，该方法结果返回零

        等价于   o1.getId() - o2.getId()
         */
        return result == 0 ? Integer.compare(o1.getId(),o2.getId()): result;
    }
}
（3）迭代器等其他接口
package com.atguigu.generic;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.function.Predicate;

public class TestGenericInterface {
    @Test
    public void test1()throws Exception{
        ArrayList<String> list = new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("atguigu");

        //需求：使用Iterator遍历集合的元素
        Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()){
            String str = iterator.next();
            System.out.println(str);
        }
    }

    @Test
    public void test2()throws Exception{
        //根据条件删除元素
        ArrayList<String> list = new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("atguigu");

        //需求：删除包含o字母的元素
        /*
        方式一：removeIf
         */
        list.removeIf(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.contains("o");
            }
        });
        System.out.println(list);
    }

    @Test
    public void test3()throws Exception{
        //根据条件删除元素
        ArrayList<String> list = new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("atguigu");

        //需求：删除包含o字母的元素
        /*
        方式二：迭代器删除
         */
        Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()){
            String str = iterator.next();
            if(str.contains("o")){
                iterator.remove();
            }
        }
        System.out.println(list);
    }
}

5.4.3 自定义泛型类或泛型接口

1、语法规范

【修饰符】 class 类名<泛型字母列表>{
    
}

【修饰符】 interface 接口名<泛型字母列表>{
    
}

注意：

  • <泛型字母列表>，可以是1个也可以是多个字母。
  • <泛型字母列表>，不推荐用单词，建议使用单个的大写字母
    • 为什么不用单词？容易引起误会

集合与泛型_第11张图片

需求：

声明一个泛型类Coordinate坐标，坐标类中应该包含两个属性，分别是x和y，代表经度和维度值。

这里的x和y的类型不确定，可能是Integer，Double，String等。

2、演示定义1个泛型

package com.atguigu.generic;

/*
声明一个泛型类Coordinate坐标，坐标类中应该包含两个属性，分别是x和y，代表经度和维度值。
这里的x和y的类型不确定，可能是Integer，Double，String等。

 */
public class Coordinate<T> {
    private T x;
    private T y;
    //同一个对象的x,y的类型一定相同

    /*public static void method(T t){//在类名后面定义的泛型，不能用于静态成员
                                //因为类名后面的泛型T，要确定具体类型，通常在new对象时，而静态方法和对象无关。

    }*/

    public Coordinate() {
    }

    public Coordinate(T x, T y) {
        this.x = x;
        this.y = y;
    }

    public T getX() {
        return x;
    }

    public void setX(T x) {
        this.x = x;
    }

    public T getY() {
        return y;
    }

    public void setY(T y) {
        this.y = y;
    }

    @Override
    public String toString() {
        return "Coordinate{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }
}

3、演示定义2个泛型

package com.atguigu.generic;

//T,U代表任意类型
public class ZuoBiao<T,U> {
    private T x;
    private U y;
    //同一个对象的x,y可能类型不同，也可能相同

    public ZuoBiao() {
    }

    public ZuoBiao(T x, U y) {
        this.x = x;
        this.y = y;
    }

    public T getX() {
        return x;
    }

    public void setX(T x) {
        this.x = x;
    }

    public U getY() {
        return y;
    }

    public void setY(U y) {
        this.y = y;
    }

    @Override
    public String toString() {
        return "ZuoBiao{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }
}

3、演示使用自定义泛型类

package com.atguigu.generic;

import org.junit.Test;

public class TestCoordinate {
    @Test
    public void test1()throws Exception{
        //创建坐标类的对象
/*        Coordinate c1 = new Coordinate("东经35.6","北纬25.6");
        Coordinate c2 = new Coordinate(35.6,25.6);*/

        //从JDK1.7开始，左边写了<>中的类型，右边可以省略，但是<>不要省略
        Coordinate<String> c1 = new Coordinate<>("东经35.6","北纬25.6");
        //c1对象的x,y都是String类型
        Coordinate<Double> c2 = new Coordinate<>(35.6,25.6);
        //c1对象的x,y都是Double
        System.out.println(c1);
        System.out.println(c2);
    }

    @Test
    public void test2()throws Exception{
        //x是String，y是Double
        ZuoBiao<String,Double> z1 = new ZuoBiao<>("东经35.6",25.6);
        //z1对象的x,y分别是String和Double
        ZuoBiao<String,String> z2 = new ZuoBiao<>("东经35.6","北纬25.6");
        //z2对象的x,y都是String
    }
}

5.5 泛型方法

5.5.1 什么情况下使用泛型方法呢？

  • 当某个方法的形参类型等不确定，可以在方法的返回值类型前面加泛型的声明。而且这个泛型只在当前方法有效，和其他方法无关。
  • 当某个静态方法的形参类型等不确定，可以在方法的返回值类型前面加泛型的声明。

总结：

  1. 如果某个类中，多个地方（多个成员变量，多个成员方法，都有未知的类型，而且它们是统一，那么就用泛型类或泛型接口）
  2. 如果是类或接口中单个方法某个类型未知，那么就使用泛型方法。
package com.atguigu.generic;

/*
Example：例子。
 */
public class Example<T> {
    public void m1(T t){
        //...
    }

    public void m2(T t){
        //...
    }
    //以上写法，表示同一个对象的m1和m2方法的形参类型一定是一样的
    //问题？如果希望同一个对象的m1和m2方法的形参类型不一样，怎么办？
    //方式一：多定义几个字母
    //方式二：每个方法单独自己定义泛型
}


package com.atguigu.generic;

public class Demo{
    public <T> void m1(T t){

    }

    public <T> void m2(T t){

    }
    //以上写法，m1和m2方法的形参类型是独立
	//m3的形参类型也是独立的
    public static <T> void m3(T t){

    }
}

集合与泛型_第12张图片

集合与泛型_第13张图片

5.5.2 之前的API中哪些方法是泛型方法？

java.util.Collection接口中有如下两个方法：

  • Object[] toArray()：不管元素什么类型，统一返回Object[]数组
  • T[] toArray(T[] a)：可以返回不同类型的数组

java.util.Arrays数组工具类中有一个这样的方法：

  • public static List asList(T… a)：将多个元素放到一个List集合中
package com.atguigu.generic;

import org.junit.Test;

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

public class TestGenericMethod {
    @Test
    public void test1()throws Exception{
        ArrayList<String> list = new ArrayList<>();
        list.add("hello");
        list.add("java");
        list.add("world");

        //Object[] toArray()：不管元素什么类型，统一返回Object[]数组
        Object[] objects = list.toArray();
        //进一步遍历objects数组
        for (int i = 0; i < objects.length; i++) {
            String str = (String) objects[i];//还得强转，有点麻烦
        }
    }

    @Test
    public void test2()throws Exception{
        ArrayList<String> list = new ArrayList<>();
        list.add("hello");
        list.add("java");
        list.add("world");

        // T[] toArray(T[] a)：可以返回不同类型的数组
//        String[] strings = new String[list.size()];
        String[] strings = new String[0];//这里长度是多少不重要，因为集合的toArray方法中只是为了得到它的类型

        System.out.println(strings.getClass());//它里面用的是这个信息，数组的类型

        String[] array = list.toArray(strings);
        //进一步遍历array数组
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i] +"，长度：" + array[i].length());
        }
    }

    @Test
    public void test3()throws Exception{
        List<String> stringList = Arrays.asList("hello", "java", "world");
        List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
        //顺便多说一句，asList方法返回的集合类型不是咱们上午学的ArrayList，Vector等类型，而是Arrays里面的一个内部类类型
        System.out.println(stringList.getClass());//class java.util.Arrays$ArrayList
        //而且这个内部类的集合，不支持添加元素，删除元素等操作
        stringList.add("chai");//java.lang.UnsupportedOperationException不支持该操作异常
    }
}

5.6 定义泛型时，能不能限定范围？

5.6.1 泛型上限

定义泛型时，能不能限定范围？

答案：可以，可以限定上限。

语法格式：

<T extends 上限>  ：这里的extends表示 T类型 <= 上限类型
                   子类 < 父类
    			   实现类 < 父接口
    			   子接口 < 父接口
 
<T extends 上限1  & 上限2 & 上限3>：这里&，表是要同时满足
    			T要同时 <= 上限1,上限2，上限3，而且相当于T同时继承或实现它们
    			上限1,上限2，上限3这些上限中，只能出现1个是类，其余只能是接口，而且类要在最左边，接口在后面。

1、演示一个上限

需求：声明一个学生类，这个学生类与我们以往声明的学生类不一样，它的属性有姓名和成绩，但是这个成绩，可能是Integer，Double，BigInteger等数字类型，但是不能是String等其他类型。

package com.atguigu.generic;

/*
需求：声明一个学生类，这个学生类与我们以往声明的学生类不一样，它的属性有姓名和成绩，
但是这个成绩，可能是Integer，Double，BigInteger等数字类型，但是不能是String等其他类型。
 */
public class Student <T extends Number>{
    private String name;
    private T score;

    public Student() {
    }

    public Student(String name, T score) {
        this.name = name;
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public T getScore() {
        return score;
    }

    public void setScore(T score) {
        this.score = score;
    }

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


package com.atguigu.generic;

import org.junit.Test;

import java.util.ArrayList;

public class TestStudent {
    @Test
    public void test1()throws Exception{
        Student<Integer> s1 = new Student<>();
        Student<Double> s2 = new Student<>();
//        Student s3 = new Student<>();//报错，因为String不满足 String <= Number条件
    }


}

2、演示多个上限

package com.atguigu.generic;

/*
需求：声明一个学生类，这个学生类与我们以往声明的学生类不一样，它的属性有姓名和成绩，
但是这个成绩，可能是Integer，Double，BigInteger等数字类型，但是不能是String等其他类型。
同时成绩的类型，必须实现Comparable接口，Cloneable接口等
 */
public class XueSheng <T extends Number & Comparable & Cloneable>{
}


package com.atguigu.generic;

import org.junit.Test;

public class TestXueSheng {
    @Test
    public void test1()throws Exception{
//        XueSheng x = new XueSheng();
        //错误，因为Integer没有实现Cloneable接口
    }
}

5.6.2 泛型擦除

泛型的擦除：一个泛型类或泛型接口在使用时，不去指定它的泛型，就称为泛型擦除。

泛型擦除后，泛型按什么类型处理呢？

如果泛型擦除了，默认按照第一个上限处理，如果没有指定上限，上限就是Object。

    @Test
    public void test2()throws Exception{
        //Student，本来应该指定T的类型，现在不指定了，称为泛型擦除
         Student s1 = new Student();
        Number score = s1.getScore();
    }

    @Test
    public void test3()throws Exception{
        //ArrayList，本来要指定E的类型，现在不指定了，称为泛型擦除
        ArrayList list = new ArrayList();
        list.add("hello");
    }

5.7 泛型通配符（了解）

5.7.1 什么情况下使用泛型通配符

当使用一个已经声明好的泛型类或泛型接口，例如：Collection、ArrayList，Comparable等，用它们声明方法的形参，或变量时，仍然无法确定，该指定为什么类型，就可以使用通配符。

5.7.2 使用泛型通配符有几种形式

答案：使用形式有3种，以ArrayList

  • ArrayList：这里?表示任意类型
  • ArrayList：这里的?表示 <= 上限的任意类型
  • ArrayList：这里的?表示 >= 下限的任意类型
package com.atguigu.wild;

import org.junit.Test;

import java.util.ArrayList;

public class TestWildCard {
    @Test
    public void test1()throws Exception{
        //调用m1方法，可以传入的集合是什么样的呢？
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("hello");
        list1.add("world");

        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(666);
        list2.add(888);

        ArrayList<Object> list3 = new ArrayList<>();
        list3.add("尚硅谷");
        list3.add(666);

        m1(list1);
        m1(list2);
        m1(list3);
    }

    public void m1(ArrayList<?> list){
        for (Object o : list) {
            System.out.println(o);
        }

        //编译时无法确定?是啥类型，编译器认为它添加什么都是有风险的，全部报错
/*        list.add("hello");
        list.add(1);
        list.add(1.0);*/
        list.add(null);
    }

    @Test
    public void test2()throws Exception{
        //调用m2方法，可以传入的集合是什么样的呢？
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("hello");
        list1.add("world");

        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(666);
        list2.add(888);

        ArrayList<Object> list3 = new ArrayList<>();
        list3.add("尚硅谷");
        list3.add(666);

//        m2(list1);//错误, list1的泛型不满足 String <= Number条件
        m2(list2);//对
//        m2(list3);//错误, list3的泛型不满足 Object <= Number条件
    }

    public void m2(ArrayList<? extends Number> list){
        for (Number number : list) {
            System.out.println(number);
        }
    }

    @Test
    public void test3()throws Exception{
        //调用m3方法，可以传入的集合是什么样的呢？
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("hello");
        list1.add("world");

        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(666);
        list2.add(888);

        ArrayList<Object> list3 = new ArrayList<>();
        list3.add("尚硅谷");
        list3.add(666);

//        m3(list1);//错误, list1的泛型不满足 String >= Number条件，String和Number没关系
//        m3(list2);//错误, list2的泛型不满足 Integer >= Number条件，Integer
        m3(list3);//对
    }

    public void m3(ArrayList<? super Number> list){
        for (Object o : list) {
            System.out.println(o);
        }
    }

    @Test
    public void test4()throws Exception{
        //演示m4方法调用
        //调用m4方法，可以传入的集合是什么样的呢？
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("hello");
        list1.add("world");

        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(666);
        list2.add(888);

        ArrayList<Object> list3 = new ArrayList<>();
        list3.add("尚硅谷");
        list3.add(666);

//        m4(list1);//错误，m4方法的形参已经明确是ArrayList，那么实参的泛型只能是
//        m4(list2);
        m4(list3);
    }

    public void m4(ArrayList<Object> list){
        for (Object o : list) {
            System.out.println(o);
        }
    }

    @Test
    public void test5()throws Exception{
        //调用m5方法，可以传入的集合是什么样的呢？
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("hello");
        list1.add("world");

        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(666);
        list2.add(888);

        ArrayList<Object> list3 = new ArrayList<>();
        list3.add("尚硅谷");
        list3.add(666);

        m5(list1);
        m5(list2);
        m5(list3);
    }

    public void m5(ArrayList list){//啥都不写，泛型擦除，唯一的小瑕疵，有警告
        for (Object o : list) {
            System.out.println(o);
        }
    }

    @Test
    public void test6()throws Exception{
        //调用m6方法，可以传入的集合是什么样的呢？
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("hello");
        list1.add("world");

        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(666);
        list2.add(888);

        ArrayList<Object> list3 = new ArrayList<>();
        list3.add("尚硅谷");
        list3.add(666);

        m6(list1,"chai");
        m6(list2,1);
        m6(list3,1.0);
    }

    public <T> void m6(ArrayList<T> list,T t){
        for (T o : list) {
            System.out.println(o);
        }

        list.add(t);
    }

    public void m7(ArrayList<?> list1, ArrayList<?> list2){//这里?独立的

    }
    public <T> void m8(ArrayList<T> list1, ArrayList<T> list2){//这里T是同一种类型

    }
}

 
  
m4(list3);
 }
 
  
public void m4(ArrayList list){
    for (Object o : list) {
        System.out.println(o);
    }
}

@Test
public void test5()throws Exception{
    //调用m5方法，可以传入的集合是什么样的呢？
    ArrayList list1 = new ArrayList<>();
    list1.add("hello");
    list1.add("world");

    ArrayList list2 = new ArrayList<>();
    list2.add(666);
    list2.add(888);

    ArrayList list3 = new ArrayList<>();
    list3.add("尚硅谷");
    list3.add(666);

    m5(list1);
    m5(list2);
    m5(list3);
}

public void m5(ArrayList list){//啥都不写，泛型擦除，唯一的小瑕疵，有警告
    for (Object o : list) {
        System.out.println(o);
    }
}

@Test
public void test6()throws Exception{
    //调用m6方法，可以传入的集合是什么样的呢？
    ArrayList list1 = new ArrayList<>();
    list1.add("hello");
    list1.add("world");

    ArrayList list2 = new ArrayList<>();
    list2.add(666);
    list2.add(888);

    ArrayList list3 = new ArrayList<>();
    list3.add("尚硅谷");
    list3.add(666);

    m6(list1,"chai");
    m6(list2,1);
    m6(list3,1.0);
}

public  void m6(ArrayList list,T t){
    for (T o : list) {
        System.out.println(o);
    }

    list.add(t);
}

public void m7(ArrayList list1, ArrayList list2){//这里?独立的

}
public  void m8(ArrayList list1, ArrayList list2){//这里T是同一种类型

}
 
  
}
 
  


 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java,mysql,开发语言)

        

            

                
    
                    
  • 单例模式详解（java）
                        搞不懂语言的程序员
重拾javajava基础知识单例模式java开发语言
                        
    以下是一个线程安全、防反射攻击、防序列化破坏的单例模式完整实现，结合真实场景问题解决方案，附带逐行中文注释：importjava.io.Serializable;importjava.lang.reflect.Constructor;/***单例模式终极实现方案（解决：线程安全、反射攻击、序列化破坏问题）*/publicclassUltimateSingletonimplementsSeriali
    
                    
    • 
                    
  • Java学习--关键字
                        月色很柔
Java学习java
                        
    Java学习--关键字前言关键字finalstaticsuperthis实现前言本文主要参考：here;若需要可直接前往学习。关键字final、Static、super、this…final区分final、finally、finalize：理解final的含义：final意为最终的含义，用来修饰类、方法和变量。修饰类：publicfinalclassClassName{}被final修饰的类不能被
    
                    
    • 
                    
  • 【Java】ReadWriteLock浅谈
                        风起云涌~
java开发语言jvm
                        
    一，概述在多读少写的场景下，可以使用读写锁优化性能。读锁本质是一种共享锁，即，如果ReadLock获取锁成功，只会阻塞WriteLock锁的获取，不会阻塞其它线程ReadLock锁的获取。而写锁就是正常的独占锁。二，简单实例一个简单demo，读者可体会。publicstaticvoidmain(String[]args){ReadWriteLocklock=newReentrantReadWrit
    
                    
    • 
                    
  • 【Java】StampedLock浅谈
                        风起云涌~
java开发语言
                        
    1，概述在多读少写的环境，相比于ReadWriteLoock，StampedLock性能更胜一筹。试着想一下，如果使用ReadWriteLoock，当1万个读请求过来时，写的操作插入，就会被阻塞。但StampedLock不会，后者不基于AQS实现，它采用乐观锁的思维。所谓的乐观，即读取的时候，不会阻塞当前线程，相应会返回一个邮票，state。读取完毕后，只要验证手上的邮票判断数据是否变化即可，随后
    
                    
    • 
                    
  • java------方法的覆盖[重写],super和final关键字
                        从未止步..
JavaSE基础java开发语言jvm
                        
    方法覆盖（也称为方法的重写，Override）定义：它是多态性的重要体现之一，是动态多态性的表现形式，他是指子类中可以定义名称，参数列表，返回值类型均与父类中某个方法完全相同的方法，我们就说子类中定义的这个方法覆盖了父类中的同名方法。举例：//anmial为父类packageanmial;publicclassAnimal{publicvoidshow
    
                    
    • 
                    
  • Android 面试（Java 篇）
                        约翰先森不喝酒
面试java面试android
                        
    Android面试（Java篇）一Java的继承机制二进程跟线程，以及线程的创建三简述wait()和sleep()的区别四如何终止一个线程五Synchronized（内置锁，线程同步）六Synchronized修饰的静态和非静态方法时为什么可以异步执行？七线程同步除了Synchronized还有别的方法么，区别在哪里八死锁产生的原因以及预防措施九Synchronized和Lock的区别十Handl
    
                    
    • 
                    
  • Android 高频面试必问之Java基础
                        2401_83641443
程序员android面试java
                        
    BootstrapClassLoader：Bootstrap类加载器负责加载rt.jar中的JDK类文件，它是所有类加载器的父加载器。Bootstrap类加载器没有任何父类加载器，如果调用String.class.getClassLoader()，会返回null，任何基于此的代码会抛出NUllPointerException异常，因此Bootstrap加载器又被称为初始类加载器。ExtClassL
    
                    
    • 
                    
  • Java学习------static、final、this、super关键字
                        日暮南城故里
Java学习记录java学习
                        
    1.static关键字static修饰的变量叫做静态变量。当所有对象的某个属性的值是相同的，建议将该属性定义为静态变量，来节省内存的开销。静态变量在类加载时初始化，存储在堆中。static修饰的方法叫做静态方法。所有静态变量和静态方法，统一使用“类名.”调用。静态方法中不能使用this关键字。因此无法直接访问实例变量和调用实例方法。静态代码块在类加载时执行，一个类中可以编写多个静态代码块，遵循自上
    
                    
    • 
                    
  • YARN 的任务提交流程是怎样的？思维导图 代码示例（java 架构)
                        用心去追梦
java架构开发语言
                        
    YARN的任务提交流程是一个复杂但有序的过程，它涉及到多个组件之间的交互。以下是详细的任务提交流程描述、思维导图结构化描述以及Java代码示例，帮助你理解如何在YARN中提交任务。YARN任务提交流程客户端提交应用程序客户端通过YARN的API向ResourceManager提交一个新应用程序。提交时需要提供ApplicationMaster的启动信息（如JAR包路径、主类名等）以及其他配置参数。
    
                    
    • 
                    
  • Android第三次面试（Java基础）
                        每次的天空
面试职场和发展javaandroid
                        
    面试题一：在Android里，Array和ArrayList区别？定义与大小：数组声明时要指定大小，之后固定；ArrayList动态，无需提前定大小。性能：二者访问元素快，时间复杂度O(1)；数组插入删除繁琐，ArrayList尾部添加快，其他位置操作慢。数据类型：数组能存基本类型和对象，ArrayList只能存对象，存基本类型需用包装类。方法功能：数组自身方法少，靠Arrays类；ArrayLi
    
                    
    • 
                    
  • 基于 ArkTS 的混合式开发示例：静态页面与本地数据交互
                        qq_55376032
harmonyos华为鸿蒙
                        
    一、实现效果1、H5段混合式开发效果图2、静态页面与本地数据交互效果图二、技术栈分析ArkTS：用于构建页面结构和逻辑，支持声明式UI和组件化开发。WebView：通过@ohos.web.webview调用H5页面，支持JavaScript交互。资源管理：使用@kit.ArkTS的util模块读取并解析本地JSON文件。自定义对话框：通过@CustomDialog实现自定义弹窗，支持动态数据加载。
    
                    
    • 
                    
  • 如何用Java轻松解析DNS报文
                        字节王德发
java技术javapython开发语言
                        
    在网络编程中，DNS（域名系统）是一个至关重要的部分。它负责将人类易于记忆的域名转换为计算机可以识别的IP地址。了解如何解析DNS报文，对于网络开发和调试都很有帮助。今天，我们就来聊聊如何利用Java来解析DNS报文，帮助你轻松理解这一过程。DNS报文的基本结构在开始之前，先简单介绍一下DNS报文的结构。DNS报文分为请求和响应两种类型，通常包含以下几个部分：头部（Header）：包含一些基本信息
    
                    
    • 
                    
  • 如何在Spring Boot中配置和使用MyBatis-Plus
                        字节王德发
java技术springbootmybatis后端
                        
    在当今的Java开发中，SpringBoot已经成为了一个非常流行的框架，而MyBatis-Plus则是一个强大的ORM框架，为开发人员提供了更简便的数据库操作方式。很多开发者都在使用SpringBoot和MyBatis-Plus的组合来快速构建高效的应用。今天就来聊聊如何在SpringBoot项目中配置和使用MyBatis-Plus，帮助你更好地理解这两者的结合。创建SpringBoot项目首先
    
                    
    • 
                    
  • Python与C ++开发匿名捐赠1对1管理APP
                        Geeker-2025
pythonc++
                        
    开发一款用于**匿名捐赠1对1管理**的App，结合Python和C++的优势，可以实现高效的后端数据处理、实时的捐赠监控以及用户友好的前端界面。以下是一个详细的开发方案，涵盖技术选型、功能模块、开发步骤等内容。##技术选型###后端（Python）-**编程语言**：Python-**Web框架**：Django或Flask-**数据库**：PostgreSQL或MySQL-**实时通信**：W
    
                    
    • 
                    
  • 【Spring Boot 中 `@Value` 注解的使用】
                        武帝为此
前后端springbootpython后端
                        
    文章目录一、前言二、@Value注解简介三、@Value注解的常见用法1.读取`application.properties`或`application.yml`配置值（1）配置文件示例（2）Java代码示例（3）测试输出2.使用`@Value`设置默认值3.读取系统环境变量和Java运行时参数4.结合SpringExpressionLanguage(SpEL)（1）基本SpEL表达式（2）引用B
    
                    
    • 
                    
  • 5. MYSQL_存储引擎二多实例安装
                        q375923078
MYSQL存储引擎slow_loggeneric_logaudit
                        
    文章目录一.MyISAM存储引擎(下)1.MyISAM还在使用的原因2.MyISAM文件组成3.myisamchk二.Memory存储引擎1.Memory介绍2.Memory特性3.Memory的物理特性三.CSV存储引擎1.CSV介绍2.CSV文件组成2.CSV特性四.Federated存储引擎1.Federated介绍2.Federated语法五.多实例安装1.多实例介绍2.安装要求3.安装操
    
                    
    • 
                    
  • 结构型模式之桥接模式：解耦抽象和实现
                        菜就多练少说
设计模式桥接模式java网络
                        
    在面向对象设计中，我们经常遇到需要扩展某些功能，但又不能修改现有代码的情况。为了避免继承带来的复杂性和维护难度，桥接模式（BridgePattern）应运而生。桥接模式是一种结构型设计模式，旨在解耦抽象部分和实现部分，使得两者可以独立变化。通过桥接模式，可以避免由于功能扩展而导致的类爆炸问题。本文将详细介绍桥接模式，讲解其概念、应用场景、优缺点，并通过Java代码示例帮助大家理解如何在实际开发中使
    
                    
    • 
                    
  • 2025年毕设ssm校园二手电瓶车交易网站论文+源码
                        SSM毕设程序源码JAVA
课程设计
                        
    本系统（程序+源码）带文档lw万字以上文末可获取一份本项目的java源码和数据库参考。系统程序文件列表开题报告内容选题背景关于校园二手交易平台的现有研究，多以综合类商品交易或书籍循环为主，而专门针对电瓶车这类高价值、强监管的校园二手交易研究较少。当前高校内电瓶车交易存在信息不对称、交易流程不规范、车牌管理脱节等问题，缺乏系统化的解决方案。部分高校虽尝试通过论坛或社群进行交易，但存在用户身份难核实、
    
                    
    • 
                    
  • JavaScript基础-获取元素
                        難釋懷
javascript开发语言
                        
    在Web开发中，使用JavaScript动态地访问和操作网页上的元素是一项基本技能。通过获取页面上的特定元素，我们可以对其进行各种操作，比如修改内容、样式或属性等。本文将详细介绍几种获取DOM元素的方法，并探讨它们的特点及适用场景。一、为什么需要获取元素？在现代Web应用中，交互性是关键。无论是响应用户的输入、更新页面内容还是实现动画效果，首先都需要定位到相关的HTML元素。掌握不同的获取元素的方
    
                    
    • 
                    
  • LeetCode——1864. 构成交替字符串需要的最小交换次数(Minimum Number of Swaps to Make the Binary...)[中等]——分析及代码（Java）
                        江南土豆
数据结构与算法LeetCodeJava题解
                        
    LeetCode——1864.构成交替字符串需要的最小交换次数[MinimumNumberofSwapstoMaketheBinaryStringAlternating][中等]——分析及代码[Java]一、题目二、分析及代码1.模拟（1）思路（2）代码（3）结果三、其他一、题目给你一个二进制字符串s，现需要将其转化为一个交替字符串。请你计算并返回转化所需的最小字符交换次数，如果无法完成转化，返回
    
                    
    • 
                    
  • 让人感到疑惑的const
                        浪裡遊
javascript开发语言ecmascript前端
                        
    const关键字在不同的编程语言中有着不同的含义和限制，但通常它被用来声明一个常量或只读变量。然而，在JavaScript中，const的行为有时可能会让人感到困惑，因为它并不总是意味着“不可变”（immutable）。让我们详细探讨一下这个问题。JavaScript中的const在JavaScript中，当你使用const声明一个变量时，你实际上是创建了一个不能重新赋值的绑定。这意味着一旦给这个
    
                    
    • 
                    
  • (LeetCode每日一题) 1963. 使字符串平衡的最小交换次数(贪心、双指针)
                        岁忧
java版刷题LeetCodeleetcode算法职场和发展javac++
                        
    题目：1963.使字符串平衡的最小交换次数方法一：对于符合要求的字符串，需要任何[0,i]部分，“[”都不比“]”少。[视为+1，]视为-1，那么任何前缀和sum都不能出现sum0){sum--;}else{while(s[j]!='['){j--;}s[j]=']';sum++;ans++;}}}returnans;}};JAVA版本：classSolution{publicintminSwap
    
                    
    • 
                    
  • JavaScript 性能优化实战：数据结构选择对性能的影响
                        deying0865423
开发语言javascript
                        
    目录数组（Array）特点与适用场景性能短板链表（LinkedList）特点与适用场景性能短板集合（Set）特点与适用场景性能短板映射（Map）特点与适用场景性能短板栈（Stack）与队列（Queue）特点与适用场景性能短板在JavaScript开发中，数据结构的选择如同搭建房屋时选择合适的建筑材料，对程序性能起着决定性作用。合理的数据结构能显著提升代码执行效率，减少资源消耗，反之则可能导致性能瓶
    
                    
    • 
                    
  • JavaScript 性能优化实战：优化 DOM 操作提升交互响应
                        deying0865423
javascript开发语言ecmascript
                        
    目录一、理解DOM操作的性能损耗二、减少DOM操作次数（一）批量操作DOM（二）缓存DOM查询结果三、优化DOM查询（一）使用更高效的查询方法（二）利用事件委托四、减少回流与重绘（一）批量修改样式（二）使用requestAnimationFrame在现代Web应用开发中，JavaScript与DOM（文档对象模型）的交互极为频繁。无论是创建动态界面、响应用户操作，还是更新页面内容，DOM操作都扮演
    
                    
    • 
                    
  • Java方法详解
                        NaclarbCSDN
java开发语言
                        
    Java方法详解方法基本概念 packagecom.arbedu.method; ​ publicclassDemo01{   //main方法   publicstaticvoidmain(String[]args){     inta;     intb;     intsum=add(1,2);//实际参数，用来调用传递的参数     System.out.println(sum);    
    
                    
    • 
                    
  • 【华为OD-E卷 -123 判断一组不等式是否满足约束并输出最大差 100分（python、java、c++、js、c）】
                        CodeClimb
算法题华为od（A+B+C+D+E卷）收录分享华为odpythonjavajavascriptc++
                        
    【华为OD-E卷-判断一组不等式是否满足约束并输出最大差100分（python、java、c++、js、c）】题目给定一组不等式，判断是否成立并输出不等式的最大差(输出浮点数的整数部分)要求:不等式系数为double类型，是一个二维数组不等式的变量为int类型，是一维数组;不等式的目标值为double类型，是一维数组不等式约束为字符串数组，只能是:“>”,“>=”,“<”,“<=”,“=”，例如，
    
                    
    • 
                    
  • 【华为OD-E卷 -122 字符统计及重排 100分（python、java、c++、js、c）】
                        CodeClimb
算法题华为od（A+B+C+D+E卷）收录分享python华为odjavac++javascript
                        
    【华为OD-E卷-字符统计及重排100分（python、java、c++、js、c）】题目给出一个仅包含字母的字符串，不包含空格，统计字符串中各个字母（区分大小写）出现的次数，并按照字母出现次数从大到小的顺序。输出各个字母及其出现次数。如果次数相同，按照自然顺序进行排序，且小写字母在大写字母之前输入描述输入一行，为一个仅包含字母的字符串输出描述按照字母出现次数从大到小的顺序输出各个字母和字母次数，
    
                    
    • 
                    
  • 【华为OD-E卷-02 最多提取子串数目100分（python、java、c++、js、c）】
                        CodeClimb
算法题华为od（A+B+C+D+E卷）收录分享华为odpythonjavac++javascript
                        
    【华为OD-E卷-最多提取子串数目100分（python、java、c++、js、c）】题目给定[a-z]，26个英文字母小写字符串组成的字符串A和B，其中A可能存在重复字母，B不会存在重复字母，现从字符串A中按规则挑选一些字母，可以组成字符串B。挑选规则如下：同一个位置的字母只能挑选一次被挑选字母的相对先后顺序不能被改变求最多可以同时从A中挑选多少组能组成B的字符串。输入描述输入为2行，第1行输
    
                    
    • 
                    
  • 【华为OD-E卷 - 高频题目全览 （关注、收藏）通过率100%以上题目可达95%（python、java、c++、js、c）】
                        CodeClimb
算法题华为od（A+B+C+D+E卷）收录分享纯小白编程入门教程（新手必看）计算机相关操作技巧（新手必看）华为odc++c语言javapythonjsjavascript
                        
    注意：如果发现代码有用例覆盖不到的情况，欢迎反馈！会在第一时间修正，更新。解题不易，如对您有帮助，欢迎点赞/收藏E卷题目全览一键跳转详情题目详情跳转01补种未成活胡杨点此跳转详情02最多提取子串数目点此跳转详情03ai面板识别点此跳转详情04流浪地球
    
                    
    • 
                    
  • PyPI 镜像源使用国内镜像，提升下载速度和安装成功率
                        zhiranyouni
同事技术分享
                        
    临时使用：可以在使用pip的时候加参数-ihttps://pypi.tuna.tsinghua.edu.cn/simple如：pipinstall-ihttps://pypi.tuna.tsinghua.edu.cn/simplepymysql这样会从清华源的镜像去安装pymysql永久修改，一劳永逸：修改~/.pip/pip.conf(没有就创建一个文件夹及文件）mkdir.pipcd.pipt
    
                    
    • 
                                
  • Nginx负载均衡
                                    510888780
nginx应用服务器
                                    
    Nginx负载均衡一些基础知识: 
 
nginx 的 upstream目前支持 4 种方式的分配 
1)、轮询（默认） 
      每个请求按时间顺序逐一分配到不同的后端服务器，如果后端服务器down掉，能自动剔除。 
2)、weight 
      指定轮询几率，weight和访问比率成正比
    
                                
    • 
                                
  • RedHat 6.4 安装 rabbitmq
                                    bylijinnan
erlangrabbitmqredhat
                                    
    在 linux 下安装软件就是折腾，首先是测试机不能上外网要找运维开通，开通后发现测试机的 yum 不能使用于是又要配置 yum 源，最后安装 rabbitmq 时也尝试了两种方法最后才安装成功 
 
机器版本： 
 
[root@redhat1 rabbitmq]# lsb_release
LSB Version:    :base-4.0-amd64:base-4.0-noarch:core
    
                                
    • 
                                
  • FilenameUtils工具类
                                    eksliang
FilenameUtilscommon-io
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2217081 一、概述 
这是一个Java操作文件的常用库，是Apache对java的IO包的封装，这里面有两个非常核心的类FilenameUtils跟FileUtils，其中FilenameUtils是对文件名操作的封装;FileUtils是文件封装，开发中对文件的操作，几乎都可以在这个框架里面找到。 非常的好用。 
    
                                
    • 
                                
  • xml文件解析SAX
                                    不懂事的小屁孩
xml
                                    
    xml文件解析:xml文件解析有四种方式， 
1.DOM生成和解析XML文档(SAX是基于事件流的解析) 
2.SAX生成和解析XML文档(基于XML文档树结构的解析) 
3.DOM4J生成和解析XML文档 
4.JDOM生成和解析XML  
本文章用第一种方法进行解析，使用android常用的DefaultHandler 
 
 
import org.xml.sax.Attributes;

    
                                
    • 
                                
  • 通过定时任务执行mysql的定期删除和新建分区，此处是按日分区
                                    酷的飞上天空
mysql
                                    
    使用python脚本作为命令脚本，linux的定时任务来每天定时执行 
  
#!/usr/bin/python
# -*- coding: utf8 -*-
import pymysql
import datetime
import calendar

#要分区的表
table_name = 'my_table'
#连接数据库的信息
host,user,passwd,db = 
    
                                
    • 
                                
  • 如何搭建数据湖架构？听听专家的意见
                                    蓝儿唯美
架构
                                    
    Edo Interactive在几年前遇到一个大问题：公司使用交易数据来帮助零售商和餐馆进行个性化促销，但其数据仓库没有足够时间去处理所有的信用卡和借记卡交易数据 
 “我们要花费27小时来处理每日的数据量，”Edo主管基础设施和信息系统的高级副总裁Tim Garnto说道：“所以在2013年，我们放弃了现有的基于PostgreSQL的关系型数据库系统，使用了Hadoop集群作为公司的数
    
                                
    • 
                                
  • spring学习——控制反转与依赖注入
                                    a-john
spring
                                    
           控制反转（Inversion of Control，英文缩写为IoC）是一个重要的面向对象编程的法则来削减计算机程序的耦合问题，也是轻量级的Spring框架的核心。 控制反转一般分为两种类型，依赖注入（Dependency Injection，简称DI）和依赖查找（Dependency Lookup）。依赖注入应用比较广泛。 
  

    
                                
    • 
                                
  • 用spool+unixshell生成文本文件的方法
                                    aijuans
xshell
                                    
    例如我们把scott.dept表生成文本文件的语句写成dept.sql,内容如下:  
　　set pages 50000; 
　　set lines 200; 
　　set trims on; 
　　set heading off; 
　　spool /oracle_backup/log/test/dept.lst; 
　　select deptno||','||dname||','||loc 
    
                                
    • 
                                
  • 1、基础--名词解析(OOA/OOD/OOP)
                                    asia007
学习基础知识
                                    
    OOA:Object-Oriented Analysis（面向对象分析方法） 
是在一个系统的开发过程中进行了系统业务调查以后，按照面向对象的思想来分析问题。OOA与结构化分析有较大的区别。OOA所强调的是在系统调查资料的基础上，针对OO方法所需要的素材进行的归类分析和整理，而不是对管理业务现状和方法的分析。 
　　OOA（面向对象的分析）模型由5个层次（主题层、对象类层、结构层、属性层和服务层）
    
                                
    • 
                                
  • 浅谈java转成json编码格式技术
                                    百合不是茶
json编码java转成json编码
                                    
    json编码;是一个轻量级的数据存储和传输的语言 
   
   在java中需要引入json相关的包,引包方式在工程的lib下就可以了 
  
JSON与JAVA数据的转换（JSON 即 JavaScript Object Natation，它是一种轻量级的数据交换格式，非 
  
常适合于服务器与 JavaScript 之间的数据的交
    
                                
    • 
                                
  • web.xml之Spring配置(基于Spring+Struts+Ibatis)
                                    bijian1013
javaweb.xmlSSIspring配置
                                    
    指定Spring配置文件位置 
<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>
			/WEB-INF/spring-dao-bean.xml,/WEB-INF/spring-resources.xml,
			/WEB-INF/
    
                                
    • 
                                
  • Installing SonarQube（Fail to download libraries from server）
                                    sunjing
InstallSonar
                                    
    1.  Download and unzip the SonarQube distribution  
2.  Starting the Web Server 
The default port is "9000" and the context path is "/". These values can be changed in &l
    
                                
    • 
                                
  • 【MongoDB学习笔记十一】Mongo副本集基本的增删查
                                    bit1129
mongodb
                                    
    一、创建复本集 
  
假设mongod,mongo已经配置在系统路径变量上，启动三个命令行窗口，分别执行如下命令： 
  
mongod --port 27017 --dbpath  data1 --replSet rs0

mongod --port 27018 --dbpath  data2 --replSet rs0

mongod --port 27019 -
    
                                
    • 
                                
  • Anychart图表系列二之执行Flash和HTML5渲染
                                    白糖_
Flash
                                    
    今天介绍Anychart的Flash和HTML5渲染功能 
  
 
 HTML5 
 
Anychart从6.0第一个版本起，已经逐渐开始支持各种图的HTML5渲染效果了，也就是说即使你没有安装Flash插件，只要浏览器支持HTML5，也能看到Anychart的图形（不过这些是需要做一些配置的）。 
这里要提醒下大家，Anychart6.0版本对HTML5的支持还不算很成熟，目前还处于
    
                                
    • 
                                
  • Laravel版本更新异常4.2.8-> 4.2.9 Declaration of ... CompilerEngine ... should be compa
                                    bozch
laravel
                                    
    昨天在为了把laravel升级到最新的版本，突然之间就出现了如下错误： 
ErrorException thrown with message "Declaration of Illuminate\View\Engines\CompilerEngine::handleViewException() should be compatible with Illuminate\View\Eng
    
                                
    • 
                                
  • 编程之美-NIM游戏分析-石头总数为奇数时如何保证先动手者必胜
                                    bylijinnan
编程之美
                                    
    


import java.util.Arrays;
import java.util.Random;

public class Nim {

	/**编程之美 NIM游戏分析
问题：
有N块石头和两个玩家A和B，玩家A先将石头随机分成若干堆，然后按照BABA...的顺序不断轮流取石头，
能将剩下的石头一次取光的玩家获胜，每次取石头时，每个玩家只能从若干堆石头中任选一堆，
    
                                
    • 
                                
  • lunce创建索引及简单查询
                                    chengxuyuancsdn
查询创建索引lunce
                                    
    import java.io.File;
import java.io.IOException;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Docume
    
                                
    • 
                                
  • [IT与投资]坚持独立自主的研究核心技术
                                    comsci
it
                                    
     
 
       和别人合作开发某项产品....如果互相之间的技术水平不同,那么这种合作很难进行,一般都会成为强者控制弱者的方法和手段..... 
 
 
       所以弱者,在遇到技术难题的时候,最好不要一开始就去寻求强者的帮助,因为在我们这颗星球上,生物都有一种控制其
    
                                
    • 
                                
  • flashback transaction闪回事务查询
                                    daizj
oraclesql闪回事务
                                    
       
闪回事务查询有别于闪回查询的特点有以下3个： 
 
（1）其正常工作不但需要利用撤销数据，还需要事先启用最小补充日志。 
 
（2）返回的结果不是以前的“旧”数据，而是能够将当前数据修改为以前的样子的撤销SQL（Undo SQL）语句。 
 
（3）集中地在名为flashback_transaction_query表上查询，而不是在各个表上通过“as of”或“vers
    
                                
    • 
                                
  • Java I/O之FilenameFilter类列举出指定路径下某个扩展名的文件
                                    游其是你
FilenameFilter
                                    
    这是一个FilenameFilter类用法的例子，实现的列举出“c:\\folder“路径下所有以“.jpg”扩展名的文件。        1   2   3   4   5   6   7   8   9   10   11   12   13   14   15   16   17   18   19   20   21   22   23   24   25   26   27   28  
    
                                
    • 
                                
  • C语言学习五函数，函数的前置声明以及如何在软件开发中合理的设计函数来解决实际问题
                                    dcj3sjt126com
c
                                    
    # include <stdio.h>

int f(void)		//括号中的void表示该函数不能接受数据，int表示返回的类型为int类型
{
	return 10;	//向主调函数返回10
}

void g(void)	//函数名前面的void表示该函数没有返回值
{
	//return 10;	//error 与第8行行首的void相矛盾
}

in
    
                                
    • 
                                
  • 今天在测试环境使用yum安装，遇到一个问题： Error: Cannot retrieve metalink for repository: epel. Pl
                                    dcj3sjt126com
centos
                                    
    今天在测试环境使用yum安装，遇到一个问题： 
Error: Cannot retrieve metalink for repository: epel. Please verify its path and try again 
  
处理很简单，修改文件“/etc/yum.repos.d/epel.repo”， 将baseurl的注释取消， mirrorlist注释掉。即可。 
&n
    
                                
    • 
                                
  • 单例模式
                                    shuizhaosi888
单例模式
                                    
    单例模式        懒汉式 
public class RunMain {

	/**
	 * 私有构造
	 */
	private RunMain() {
	}
	
    /**
     * 内部类，用于占位，只有
     */
	private static class SingletonRunMain {
		priv
    
                                
    • 
                                
  • Spring Security（09）——Filter
                                    234390216
Spring Security
                                    
    Filter 
目录 
1.1     Filter顺序 
1.2     添加Filter到FilterChain 
1.3     DelegatingFilterProxy 
1.4     FilterChainProxy 
1.5
    
                                
    • 
                                
  • 公司项目NODEJS实践0.1
                                    逐行分析JS源代码
mongodbnginxubuntunodejs
                                    
      
一、前言 
        前端如何独立用nodeJs实现一个简单的注册、登录功能，是不是只用nodejs+sql就可以了？其实是可以实现，但离实际应用还有距离，那要怎么做才是实际可用的。 
        网上有很多nod
    
                                
    • 
                                
  • java.lang.Math
                                    liuhaibo_ljf
javaMathlang
                                    
    System.out.println(Math.PI); 
System.out.println(Math.abs(1.2)); 
System.out.println(Math.abs(1.2)); 
System.out.println(Math.abs(1)); 
System.out.println(Math.abs(111111111)); 
System.out.println(Mat
    
                                
    • 
                                
  • linux下时间同步
                                    nonobaba
ntp
                                    
    今天在linux下做hbase集群的时候，发现hmaster启动成功了，但是用hbase命令进入shell的时候报了一个错误  PleaseHoldException: Master is initializing，查看了日志，大致意思是说master和slave时间不同步，没办法，只好找一种手动同步一下，后来发现一共部署了10来台机器，手动同步偏差又比较大，所以还是从网上找现成的解决方
    
                                
    • 
                                
  • ZooKeeper3.4.6的集群部署
                                    roadrunners
zookeeper集群部署
                                    
    ZooKeeper是Apache的一个开源项目，在分布式服务中应用比较广泛。它主要用来解决分布式应用中经常遇到的一些数据管理问题，如：统一命名服务、状态同步、集群管理、配置文件管理、同步锁、队列等。这里主要讲集群中ZooKeeper的部署。 
  
1、准备工作 
我们准备3台机器做ZooKeeper集群，分别在3台机器上创建ZooKeeper需要的目录。 
  
数据存储目录
    
                                
    • 
                                
  • Java高效读取大文件
                                    tomcat_oracle
java
                                    
    　　读取文件行的标准方式是在内存中读取，Guava 和Apache Commons IO都提供了如下所示快速读取文件行的方法：   　　Files.readLines(new File(path), Charsets.UTF_8);   　　FileUtils.readLines(new File(path));   　　这种方法带来的问题是文件的所有行都被存放在内存中，当文件足够大时很快就会导致
    
                                
    • 
                                
  • 微信支付api返回的xml转换为Map的方法
                                    xu3508620
xmlmap微信api
                                    
    举例如下： 
<xml> 
   <return_code><![CDATA[SUCCESS]]></return_code> 
   <return_msg><![CDATA[OK]]></return_msg> 
   <appid><
    
                                
    •