当前位置: 首页 > news >正文

做汽车团购的网站/常见的网络直接营销有哪些

做汽车团购的网站,常见的网络直接营销有哪些,北京新闻网,廉洁四川官方网权威发布文章目录 1、常用API 1.1、Math1.2、System1.3、Object1.4、Arrays1.5、基本类型包装类 1.5.1、基本类型包装类概述1.5.2、Integer1.5.3、int和String相互转换1.5.4、自动装箱和拆箱 1.6、日期类 1.6.1、Date类1.6.2、SimpleDateFormat类 1.6.2.1、格式化(从Date到…
文章目录
  • 1、常用API
    • 1.1、Math
    • 1.2、System
    • 1.3、Object
    • 1.4、Arrays
    • 1.5、基本类型包装类
      • 1.5.1、基本类型包装类概述
      • 1.5.2、Integer
      • 1.5.3、int和String相互转换
      • 1.5.4、自动装箱和拆箱
    • 1.6、日期类
      • 1.6.1、Date类
      • 1.6.2、SimpleDateFormat类
        • 1.6.2.1、格式化(从Date到String)
        • 1.6.2.2、解析(从String到Date)
      • 1.6.3、Calendar类
    • 1.7、String
    • 1.8、StringBuilder
    • 1.9、Scaner
    • 1.10、Random
  • 2、异常
    • 2.1、异常概述
    • 2.2、JVM的默认处理方案
    • 2.3、异常处理
    • 2.4、异常处理之try…catch…
    • 2.5、Throwable的成员方法
    • 2.6、编译时异常和运行时异常的区别
    • 2.7、异常处理之throws
    • 2.8、自定义异常
    • 2.9、throws和throw的区别
  • 3、集合进阶
    • 3.1、Collection
    • 3.2、List
      • 3.2.1、List
      • 3.2.2、List并发修改异常
      • 3.2.3、ListIterator
      • 3.2.4、增加for循环
      • 3.2.5、数据结构
        • 3.2.5.1、栈
        • 3.2.5.2、列
        • 3.2.5.3、数组
        • 3.2.5.4、链表
      • 3.2.6、List集合子类特点
      • 3.2.7、LinkedList集合的特有功能
    • 3.3、Set
      • 3.3.1、Set集合概述和特点
      • 3.3.2、哈希值
      • 3.3.3、HashSet集合添加一个元素的过程
      • 3.3.4、哈希表
      • 3.3.5、LinkedHashSet
      • 3.3.6、TreeSet
      • 3.3.7、自然排序Comparable的使用
      • 3.3.8、比较器排序Comparator的使用
    • 3.4、泛型
      • 3.4.1、泛型概述
      • 3.4.2、泛型类
      • 3.4.3、泛型方法
      • 3.4.4、泛型接口
      • 3.4.5、类型通配符
      • 3.4.6、可变参数
      • 3.4.7、可变参数的使用
    • 3.5、Map
      • 3.5.1、Map集合概述
      • 3.5.2、Map集合的基本功能
      • 3.5.3、Map集合的获取功能
      • 3.5.4、Map集合的遍历
      • 3.5.5、HashMap的案例
      • 3.5.6、ArrayList中嵌套HashMap
      • 3.5.7、HashMap中嵌套ArrayList
      • 3.5.8、统计字符串中每个字符出现的次数
    • 3.6、Collections
      • 3.6.1、Collections的概述
      • 3.6.2、对ArrayList排序

1、常用API

1.1、Math

方法名

说明

public static int abs(int a)

返回参数的绝对值

public static double ceil(double a)

返回大于或等于参数的最小double的值,等于一个整数

public static floor(double a)

返回小于或等于参数的最大double值,等于一个整数

public static int round(float a)

按四舍五入返回最接近参数的int

public static int max(int a,int b)

返回两个int值中的较大值

public static int min(int a,int b)

返回两个int值中的较小值

public static double pow(double a,double b)

返回a的b次幂的值

public static double random()

返回double的正值[0.0,1.0)

示例:

public class MathDemo {public static void main(String[] args) {
//        public static int abs(int a)	返回参数的绝对值System.out.println(Math.abs(88));System.out.println(Math.abs(-88));System.out.println("*************");
//        public static double ceil(double a)	返回大于或等于参数的最小double的值,等于一个整数System.out.println(Math.ceil(9.4));//输出10.0System.out.println(Math.ceil(9.5));//输出10.0System.out.println("*************");
//        public static floor(double a)	返回小于或等于参数的最大double值,等于一个整数System.out.println(Math.floor(9.4));//输出9.0System.out.println(Math.floor(9.5));//输出9.0System.out.println("*************");
//        public static int round(float a)	按四舍五入返回最接近参数的intSystem.out.println(Math.round(9.4F));//输出9System.out.println(Math.round(9.5F));//输出10System.out.println("*************");
//        public static int max(int a,int b)	返回两个int值中的较大值System.out.println(Math.max(2,8));System.out.println("*************");
//        public static int min(int a,int b)	返回两个int值中的较小值System.out.println(Math.min(2,8));System.out.println("*************");
//        public static double pow(double a,double b)	返回a的b次幂的值System.out.println(Math.pow(2,3));//输出8.0System.out.println("*************");
//        public static double random()	返回double的正值[0.0,1.0)System.out.println(Math.random());//[0.0,1.0)System.out.println((int)(Math.random()*100));//[1,99)之间的随机int数System.out.println((int)(Math.random()*100)+1);//[1,100)之间的随机int数System.out.println((int)(Math.random()*91)+10);//[10,100)之间的随机int数}
}

1.2、System

  • System包含几个有用的类字段和方法,它不能被实例化。

System类的常用方法:

方法名

说明

public static void exit(int status)

终止当前运行的Java虚拟机,非零表示异常终止。

public static long currentTimeMillis()

返回当前时间(以毫秒为单位)

1.3、Object

方法名

说明

toString()

建议所有子类覆盖此方法。

public boolean equals?(Object obj)

比较对象是否相等。默认比较地址,重写可以比较内容。

1.4、Arrays

  • Arrays类包含用于操作数组的各种方法:

方法名

说明

public static String toString?(int[] a)

返回指定数组的内容的字符串表示形式

public static void sort?(int[] a)

按照数字顺序排序指定的数组

工具类的设计思想:

  • 构造方法用private修饰,主要是不让外部创建对象。
  • 成员用public static修饰,主要是让外部可以用类名调用。

1.5、基本类型包装类

1.5.1、基本类型包装类概述
  • 将基本类型封装成对象的好处在于可以在对象中定义更多的功能方法操作数据。
  • 常用的操作之一:用于将基本数据类型与字符串之间的转换。

基本数据类型

包装类

byte

Byte

short

Short

int

Integer

long

Long

float

Float

doube

Double

char

Character

boolean

Boolean

1.5.2、Integer
  • 包装一个对象中的原始类型int的值。

方法名

说明

public Integer(int value)

根据int值创建Integer对象(已过时)

public Integer(String s)

根据String值创建Integer对象(已过时)

public static Integer valueOf(int i)

返回表示指定的int值的Integer实例

public static Integer valueOf(String s)

返回一个保存指定值的Integer对象String

1.5.3、int和String相互转换

int转String

		/*int转String*/int number=100;//方式一:String s=""+number;//方式二:String s1=String.valueOf(number);

String转int

		/*String转int*/String s="100";//方式一:String转Integer转intInteger i=Integer.valueOf(s);int x=i.intValue();//方式二:int y=Integer.parseInt(s);
1.5.4、自动装箱和拆箱
  • 装箱:把基本数据类型转换为对应的包装类类型。

    //装箱
    Integer i=Integer.valueOf(100);
    Integer j=100;//自动装箱,JDK5以后简化成了此种写法。
    
  • 拆箱:把包装类类型转换为对应的基本数据类型。

    //拆箱
    Integer i=100;//拆箱
    ii=ii.intValue()+1;//ii.intValue()是拆箱
    ii+=1;// 自动拆箱
    

注意: 使用包装类类型时,若操作,最好先判断是否为null
只要是对象,使用前必须进行不为null的判断。

1.6、日期类

1.6.1、Date类
  • Date代表了一个特定的时间,精确到毫秒

方法名

说明

public Date()

分配一个Date对象,并初始化,以代表它被分配到的时间,精确到毫秒

public Date (long date)

分配一个Date对象,并将其初始化为表示从标准基准时间起指定的毫秒数

public long getTime()

获取的是日期对象从1970年1月1日00:00:00到现在的毫秒值

public void setTime(long time)

设置时间,给的是毫秒值

1.6.2、SimpleDateFormat类
  • 用于日期格式化和解析。

方法名

说明

pubblic SimpleDateFormat()

构造一个SimpleDateFormat,使用默认模式和日期格式

public SimpleDateFormat(String pattern)

构造一个SimpleDateFormat模式使用给定的模式和默认的日期格式

1.6.2.1、格式化(从Date到String)

public final format(Date date):将日期格式化成日期/时间字符串
默认格式

import java.util.Date;
import java.text.SimpleDateFormat;
public class SimpleDateFormatDemo {public static void main(String[] args) {Date d=new Date();SimpleDateFormat sdf=new SimpleDateFormat();String s=sdf.format(d);System.out.println(s);}
}

指定格式

		Date d=new Date();SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");String t=sdf.format(d);System.out.println(t);
1.6.2.2、解析(从String到Date)

public Date parse(String source):从给定字符串的开始解析文本生成日期

import java.text.ParseException;
import java.util.Date;
import java.text.SimpleDateFormat;
public class SimpleDateFormatDemo {public static void main(String[] args) throws ParseException {String t="2022-02-28 12:00:01";SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");Date d=sdf.parse(t);System.out.println(d);}
}
1.6.3、Calendar类
  • Calendar提供了一个类方法getInstance用于获取Calendar对象,其日历字段已使用当前日期和时间初始化:
    Calendar rightNow=Calendar.getInstance();

    import java.util.Calendar;
    public class CalendarDemo {
    public static void main(String[] args) {
    Calendar c=Calendar.getInstance();
    int year=c.get(Calendar.YEAR);
    int month=c.get(Calendar.MONTH)+1;
    int date=c.get(Calendar.DATE);
    System.out.println(year+“年”+month+“月”+date+“日”);
    }
    }

Calendar常用方法:

方法名

说明

public int get(int field)

返回给定日历字段的值

public abstract void add(int field,int amount)

根据日历的规则,将指定的时间量添加或减去给定的日历字段

public final void set(int year,int month,int date)

设置当前日历的年月日

import java.util.Calendar;
public class CalendarDemo {public static void main(String[] args) {Calendar c=Calendar.getInstance();//public abstract void add(int field,int amount)c.add(Calendar.YEAR,-2);//两年前int year=c.get(Calendar.YEAR);int month=c.get(Calendar.MONTH)+1;int date=c.get(Calendar.DATE);System.out.println(year+"年"+month+"月"+date+"日");// public final void set(int year,int month,int date)c.set(2000,0,1);//将日历设置为2000-1-1year=c.get(Calendar.YEAR);month=c.get(Calendar.MONTH)+1;//月份从0开始date=c.get(Calendar.DATE);System.out.println(year+"年"+month+"月"+date+"日");}
}

二月天案例:

import java.util.Scanner;
import java.util.Calendar;
public class CalendarDemo {public static void main(String[] args) {Scanner sc=new Scanner(System.in);System.out.println("请输入年份:");int year=sc.nextInt();Calendar c=Calendar.getInstance();//将日历设置为3月1日,再减一天就是2月的最后一天c.set(year,2,1);c.add(Calendar.DATE,-1);int date=c.get(Calendar.DATE);System.out.println(year+"年二月有"+date);}
}

1.7、String

1.8、StringBuilder

1.9、Scaner

1.10、Random

2、异常

2.1、异常概述

  • 异常:就是程序出现了不正常的情况

#mermaid-svg-4t2aA5Fz629v7TEb {font-family:“trebuchet ms”,verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-4t2aA5Fz629v7TEb .error-icon{fill:#552222;}#mermaid-svg-4t2aA5Fz629v7TEb .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-4t2aA5Fz629v7TEb .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-4t2aA5Fz629v7TEb .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-4t2aA5Fz629v7TEb .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-4t2aA5Fz629v7TEb .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-4t2aA5Fz629v7TEb .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-4t2aA5Fz629v7TEb .marker{fill:#333333;stroke:#333333;}#mermaid-svg-4t2aA5Fz629v7TEb .marker.cross{stroke:#333333;}#mermaid-svg-4t2aA5Fz629v7TEb svg{font-family:“trebuchet ms”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-4t2aA5Fz629v7TEb .label{font-family:“trebuchet ms”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-4t2aA5Fz629v7TEb .cluster-label text{fill:#333;}#mermaid-svg-4t2aA5Fz629v7TEb .cluster-label span{color:#333;}#mermaid-svg-4t2aA5Fz629v7TEb .label text,#mermaid-svg-4t2aA5Fz629v7TEb span{fill:#333;color:#333;}#mermaid-svg-4t2aA5Fz629v7TEb .node rect,#mermaid-svg-4t2aA5Fz629v7TEb .node circle,#mermaid-svg-4t2aA5Fz629v7TEb .node ellipse,#mermaid-svg-4t2aA5Fz629v7TEb .node polygon,#mermaid-svg-4t2aA5Fz629v7TEb .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-4t2aA5Fz629v7TEb .node .label{text-align:center;}#mermaid-svg-4t2aA5Fz629v7TEb .node.clickable{cursor:pointer;}#mermaid-svg-4t2aA5Fz629v7TEb .arrowheadPath{fill:#333333;}#mermaid-svg-4t2aA5Fz629v7TEb .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-4t2aA5Fz629v7TEb .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-4t2aA5Fz629v7TEb .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-4t2aA5Fz629v7TEb .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-4t2aA5Fz629v7TEb .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-4t2aA5Fz629v7TEb .cluster text{fill:#333;}#mermaid-svg-4t2aA5Fz629v7TEb .cluster span{color:#333;}#mermaid-svg-4t2aA5Fz629v7TEb div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:“trebuchet ms”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-4t2aA5Fz629v7TEb :root{–mermaid-font-family:“trebuchet ms”,verdana,arial,sans-serif;}

Throwable

Error

Exception

RuntimeException

非RuntimeException

  • Error:严重问题,不需要处理
  • Exception:称为异常类,它表示程序本身可以处理的问题。
  • RuntimeException:在编译期是不检查的,出现问题后,需要我们回来修改代码。
  • 非RuntimeException:编译期就必须处理,否则程序不能通过编译。

2.2、JVM的默认处理方案

如果程序出现 问题,我们没有做任何处理,最终JVM会做默认的处理。

  • 把异常的名称,异常原因及异常出现的位置等信息输出在了控制台。
  • 程序停止执行。

2.3、异常处理

如果程序出现了问题,我们需要自己来处理,有两种方案:

  • try...catch...
  • throws

格式:

try{可能出现异常的代码;
}catch(异常类名 变量名){异常处理代码;
}

执行流程:

  • 程序从try里面的代码开始执行。
  • 出现异常,会自动生成一个异常类对象,该异常对象将被提交给Java运行时系统。
  • 当Java运行时系统接收异常对象时,会到catch中云找匹配的异常类,找到后进行异常的处理。
  • 执行完毕后,程序还可继续往下执行。

2.4、异常处理之try…catch…

public class ExceptionDemo {public static void main(String[] args) {System.out.println("开始");methood();System.out.println("异常处理完毕仍可继续运行");}public static void methood(){try{int[] arr={1,2,3};System.out.println(arr[3]);}catch(ArrayIndexOutOfBoundsException e){System.out.println("数组下标越界");e.printStackTrace();}}}

2.5、Throwable的成员方法

方法名

说明

public String getMessage()

返回此throwable的详细消息字符串

public String toString()

返回此可抛出的简短描述

public void printStackTrace()

把异常的错误信息输出在控制台

2.6、编译时异常和运行时异常的区别

  • Java中的异常被分为两大类:编译时异常和运行时异常,也被称为受检异常和非受检异常。
  • 所有的RuntimeException类及其子类被称为运行时异常,其他的异常都是编译时异常。

编译时异常: 必须显示处理,否则程序就会发生错误,无法通过编译。
运行时异常: 无需显示处理,也可以和编译时异常一样处理。

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class ExceptionDemo {public static void main(String[] args) {System.out.println("开始");methood();System.out.println("结束");}public static void methood(){try{String s="2000-01-01";SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");Date d=sdf.parse(s);}catch (ParseException e){e.printStackTrace();}}}

2.7、异常处理之throws

虽然可以通过try…catch…对异常处理,但并不是所有情况都有权限进行异常的处理。即,有些时候可能出现的异常我们处理不了。
针对这种情况,Java提供了throws的处理方案。

格式:

throws 异常类名;

注意:这个格式是跟在方法的括号后面的。

  • 编译时异常必须要进行处理,两种处理方案:try...catch....或者throws,将来谁调用谁处理。

  • 运行时异常可以不处理,出现问题后,需要回来修改代码。

    //编译时异常
    public static void methood() throws ParseException {       String s="2000-01-01";SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");Date d=sdf.parse(s);          
    }//运行时异常
    public static void methood1() throws ArrayIndexOutOfBoundsException{int arr[]={1,2,3};System.out.println(arr[3]);
    }
    

2.8、自定义异常

格式:

public class 异常类名 extends Exception{无参构造带参构造
}

示例:

  • 自定义异常类

    //自定义异常类
    package com.test1;public class ScoreException extends Exception {public ScoreException(){}public ScoreException(String message){super(message);}
    }
    
  • 抛出异常。

    package com.test1;public class Score{public static void check(int score) throws ScoreException{if(score<0||score>100){throw new ScoreException("分数不在0-100之间");}else{System.out.println("分数正常");}}
    }
    
  • 处理异常

    package com.test1;import java.util.Scanner;public class ScoreDemo {public static void main(String[] args) {Scanner sc=new Scanner(System.in);System.out.println("请输入分数:");int score=sc.nextInt();try{Score.check(score);}catch(ScoreException e){e.printStackTrace();}}}
    

注意:

  • 运行时异常类继承自:RuntimeException
  • 编译时异常类继承自Exception

2.9、throws和throw的区别

throws

  • 用在方法声明后,跟的是异常类名。
  • 表示抛出异常,由该方法的调用者来处理。
  • 表示出现异常的一种可能性,并不一定发生这些异常。
    throw
  • 用在方法体内,跟的是异常对象名。
  • 表示抛出异常,由方法体内的语句处理。
  • 执行throw一定抛出了某种异常。

3、集合进阶

集合体系结构
在这里插入图片描述

3.1、Collection

  • 是单列集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素。
  • JDK不提供此接口的任何直接实现,它提供更具体的子接口实现,如SetList

创建Collection集合的对象:

  • 多态的方式

  • 具体的实现类ArrayList

    import java.util.Collection;
    import java.util.ArrayList;
    public class CollectionDemo {
    public static void main(String[] args) {
    Collection c=new ArrayList();
    c.add(“Hello”);
    c.add(“world”);
    System.out.println©;
    }
    }

Collection集合常用方法:

方法名

说明

boolea:n add(E e)

添加元素

boolean remove(Object o)

从集合中移除指定的元素

void clear()

清空集合中的元素

boolean contains(Object o)

判断集合中是否存在指定的元素

boolean isEmpty()

判断集合是否为空

int size()

集合的长度,也就是集合中元素的个数

Collection集合的遍历:

  • Iterator:迭代器,集合的专用 遍历方式。
  • Iteratoriterator():返回此集合中元素的迭代器,通过集合的iterator()方法得到。
  • 迭代器是通过集合的iterator()方法得到的,所以我们说它是依赖于集合面存在的。

Iterator中的常用方法:

  • E next():返回迭代中的下一个元素。

  • boolean hasNext():如果迭代具有更多元素,则返回true

    import java.util.Collection;
    import java.util.ArrayList;
    import java.util.Iterator;
    public class CollectionDemo {
    public static void main(String[] args) {
    Collection c=new ArrayList();
    c.add(“Hello”);
    c.add(“world”);
    c.add(“java”);
    Iterator it=c.iterator();
    while(it.hasNext()){
    String s=it.next();
    System.out.println(s);
    }

    }
    

    }

3.2、List

3.2.1、List

List集合概述

  • 有序集合(也称序列),用户可精确控制列表中每个元素的插入位置。用户可通过索引访问元素。
  • 与Set集合不同,列表通常允许重复的元素。

List集合特点

  • 有序:存储和取出的元素顺序一致。
  • 可重复:存储的元素可以重复。

List集合特有方法:

方法名

说明

void add(int index,E element)

在此集合中的指定位置插入指定的元素

E remove(int index)

删除指定索引处的元素,返回被删除的元素

E set(int index,E element)

修改指定索引处的元素,返回被修改的元素

E get(int index)

返回指定索引处的元素

示例:

import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
public class ListDemo {public static void main(String[] args) {List<String> list=new ArrayList<String>();list.add("Hello");list.add("world");list.add("java");//第一种遍历:迭代器遍历Iterator<String> it=list.iterator();while(it.hasNext()){String s=it.next();System.out.println(s);}//第二种遍历:for循环方式for(int i=0;i<list.size();i++){String s=list.get(i);System.out.println(s);}}
}
3.2.2、List并发修改异常

并发修改异常

  • ConcurrentModificationException

产生原因

  • 迭代器遍历的过程中,通过集合对象修改了集合中元素的长度,造成了迭代器猎取元素中判断预期修改值和实际值不一致。

解决方案:

  • 用for循环遍历,然后用集合对象做对应的操作即可。

    import java.util.List;
    import java.util.ArrayList;
    import java.util.Iterator;
    public class ListDemo {
    public static void main(String[] args) {
    List list=new ArrayList();
    list.add(“Hello”);
    list.add(“world”);
    list.add(“java”);
    //第一种遍历:迭代器遍历
    Iterator it=list.iterator();
    while(it.hasNext()){
    String s=it.next();//触发并发修改异常
    if(s.equals(“world”)){
    list.add(“aaa”);
    }
    }
    //用for循环方式遍历可解决List并发修改异常的问题:
    for(int i=0;i<list.size();i++){
    String s=list.get(i);
    if(s.equals(“world”)){
    list.add(“aaa”);
    }
    }
    }
    }

3.2.3、ListIterator

ListIterator列表迭代器

  • 通过List集合的listIterator()方法得到,所以说它是List集合特有的迭代器。
  • 可沿任一方向遍历列表的列表迭代器,迭代期间修改列表,并获取列表中迭代器的当前位置。

ListIterator中的常用方法:

  • E next():返回迭代中的下一下元素。

  • boolean hasNext():如果迭代具有更多元素,则返回true。

  • E previous():返回列表中的上一个元素。

  • boolean hasPrevious():如果此列表迭代器在相反方向遍历列表时具有更多元素,则返回true。

  • void add(E e):将指定的元素插入列表。

    import java.util.List;
    import java.util.ArrayList;
    import java.util.ListIterator;
    public class ListIteratorDemo {
    public static void main(String[] args) {
    List list=new ArrayList();
    list.add(“hello”);
    list.add(“world”);
    list.add(“java”);
    ListIterator lit=list.listIterator();
    while(lit.hasNext()){
    String s=lit.next();
    System.out.println(s);
    }

        System.out.println("---------");while(lit.hasPrevious()){String s = lit.previous();System.out.println(s);}
    }
    

    }

ListIterator不触发并发修改异常

import java.util.List;
import java.util.ArrayList;
import java.util.ListIterator;
public class ListIteratorDemo {public static void main(String[] args) {List<String> list=new ArrayList<String>();list.add("hello");list.add("world");list.add("java");ListIterator<String> lit=list.listIterator();while(lit.hasNext()){String s = lit.next();if(s.equals("world"))lit.add("javaEE");}System.out.println(list);}
}
3.2.4、增加for循环
  • 简化数组和Collection集合的遍历。
  • 实现Iterable接口的类允许其对象成为增强型for语句的目标
  • JDK5之后出现,其内部原理是一个Iterator迭代器。

增强for的格式:

for(元素的数据类型变量名:数组或者Collection集合){//在此处使用变量即可,该变量就是元素。
}

示例:

int[] arr={1,2,3,4,5};
for(int i:arr){System.out.println(i);
}
3.2.5、数据结构
3.2.5.1、栈
  • 先进后出。
3.2.5.2、列
  • 先进先出。
3.2.5.3、数组
  • 数组是一种查询快,增删慢的模型。
  • 查询数据通过索引定位,查询任意数据耗时相同,查询速度快。
  • 删除数据时,要将原始数据删除,同时后面两个数据前移,删除效率低。
  • 添加数据时,添加位置后的每人数据后移,再添加元素,添加效率极低。
3.2.5.4、链表
  • 链表是一种增删快的模型(对比数组)。
  • 链表是一种查询慢的模型(对比数组)。
  • 查询数据是否存在,必须从头(head)开始查询 。
    在这里插入图片描述
3.2.6、List集合子类特点

List集合常用子类:ArrayListLinkedList

  • ArrayList:底层数据结构是数组,查询快,增删慢
  • LinkedList:底层数据结构是链表,查询慢,增删快。

ArrayList集合的三种遍历方式

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.ListIterator;
public class test6 {public static void main(String[] args) {ArrayList<String> array=new ArrayList<String>();array.add("Hello");array.add("world");array.add("java");for(String s:array){System.out.println(s);}System.out.println("************");for(int i=0;i<array.size();i++){String s=array.get(i);System.out.println(s);}System.out.println("************");ListIterator<String> it=array.listIterator();while(it.hasNext()){String s=it.next();System.out.println(s);}System.out.println("************");while(it.hasPrevious()){String s=it.previous();System.out.println(s);}//LinkedList与ArrayList三种遍历方法相同LinkedList<String> linkedList=new LinkedList<String>();linkedList.add("aaa");linkedList.add("bbb");linkedList.add("ccc");for(String s:linkedList){System.out.println(s);}}
}
3.2.7、LinkedList集合的特有功能

方法名

说明

puclic void addFirst(E e)

在该列表开头插入指定的元素

public void addLast(E e)

将指定的元素追加到此列表的末尾

public E getFirst()

返回此列表中的第一个元素

public E getLast()

返回此列表中的最后一个元素

public E removeFirst()

从此列表中删除并返回第一个元素

public E removeLast()

从此列表中删除并返回最后一个元素

3.3、Set

3.3.1、Set集合概述和特点

Set集合特点

  • 不包含重复元素的集合。

  • 没有带索引的方法,所以不能使用普通for循环遍历。

    import java.util.Set;
    import java.util.HashSet;
    public class SetDemo {
    public static void main(String[] args) {
    Set set=new HashSet();
    set.add(“Hello”);
    set.add(“world”);
    set.add(“java”);

        //没有带索引的方法,所以不能使用普通for循环遍历//只能使用增强for循环遍历for(String s:set){System.out.println(s);}
    }
    

    }

3.3.2、哈希值

哈希值: 是JDK根据对象的地址或者字符串或者数字计算出来的int类型的数值。

Object类中有一个方法可获取对象的哈希值:

  • public int hashCode():返回对象的哈希值。

对象的哈希值特点

  • 同一个对象多次调用hashCode()方法返回的哈希值是相同的。
  • 默认情况下,不同对象的哈希值是不相同的。
  • 通过重写Object中的hashCode方法,可以实现不同对象的哈希值是相同的。
3.3.3、HashSet集合添加一个元素的过程

在这里插入图片描述
HashSet集合存储元素:

  • 要保证元素唯一性,需要重写hashCode()equals()
3.3.4、哈希表
  • JDK8之前,底层采用数组+链表实现,可以说是一个元素为链表的数组。
  • JDK8以后,在长度比较长的时候,底层实现了优化。
    在这里插入图片描述
3.3.5、LinkedHashSet

LinkedHashSet集合特点:

  • 哈希表和链表实现的Set接口,具有可预测的迭代次序。

  • 由链表保证元素有序,也就是说元素的存储和取出顺序是一致的。

  • 由哈希表保证元素唯一,也就是说没有重复的元素经。

    import java.util.LinkedHashSet;

    public class LinkedHashSetDemo {
    public static void main(String[] args) {
    LinkedHashSet linkedHashSet=new LinkedHashSet();
    linkedHashSet.add(“Hello”);
    linkedHashSet.add(“world”);
    linkedHashSet.add(“java”);
    for(String s:linkedHashSet){
    System.out.println(s);
    }
    }
    }

3.3.6、TreeSet

TreeSet集合特点

  • 元素有序,这里的顺序不是指存储和取出的顺序,而是按照一定的规则进行排序,具体排序方式取决于构造方法。

    • TreeSet()根据其元素的自然排序进行排序。
    • TreeSet(Comparator comparator)根据指定的比较器进行排序
  • 没有带索引的方法,所以不能使用普通for循环遍历

  • 由于是Set集合,所以不包含有重复元素的集合

    import java.util.TreeSet;

    public class TreeSetDemo {
    public static void main(String[] args) {
    TreeSet treeSet=new TreeSet();
    treeSet.add(10);
    treeSet.add(50);
    treeSet.add(30);
    treeSet.add(20);
    treeSet.add(40);
    for(Integer i:treeSet){
    System.out.println(i);
    }
    }
    }

3.3.7、自然排序Comparable的使用
  • 存储学生对象并遍历,创建TreeSet集合使用无参构造方法。
  • 要求:按照年龄从小到大排序,年龄相同时,按照姓名的字母排序。

结论:

  • Student类不实现Comparable接口,会触发ComparablClassCastException异常。
  • 实现Comparable接口就必须要实现 compareTo?(T o)方法。

compareTo?(T o)方法的返回值:

  • 返回0,会认为是重复元素不添加(添加的第一个元素除外)

  • 返回正数,按存储的顺序正着输出。

  • 返回负数,按存储的顺序倒着输出。

    //Student.java
    public class Student implements Comparable {
    private String name;
    private int age;

    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 int compareTo(Student s){
    /*return 0; //会认为是重复元素不添加进TreeSet(添加的第一个元素除外)return 1;//按存储的顺序升序输出。return -1;//按存储的顺序倒着输出。*//*//按照年龄从小到大排序return this.age-s.age;//按照年龄从大到小排序return s.age-this.age;*/int num=this.age-s.age;return num==0?this.name.compareTo(s.name):num;}
    

    }

    //TreeSetDemo.java
    import java.util.TreeSet;

    public class TreeSetDemo {
    public static void main(String[] args) {
    TreeSet treeSet=new TreeSet();
    Student s1=new Student(“bbb”,20);
    Student s2=new Student(“aaa”,20);
    Student s3=new Student(“ccc”,21);
    Student s4=new Student(“ddd”,30);
    Student s5=new Student(“eee”,19);
    treeSet.add(s1);
    treeSet.add(s2);
    treeSet.add(s3);
    treeSet.add(s4);
    treeSet.add(s5);
    for(Student s:treeSet){
    System.out.println(s.getName()+“,”+s.getAge());
    }
    }
    }

  • 用TreeSet集合存储自定义对象,无参构造方法使用的是自然排序对元素进行排序的。

  • 自然排序,就是让元素所属的类实现Comparable接口,重写compareTo方法。

  • 重写方法时,一定要注意排序规则按要求的主要条件和次要条件来写。

3.3.8、比较器排序Comparator的使用
  • 用TreeSet集合存储自定义对象,带参构造方法使用的是比较器排序对元素进行排序。

  • 比较器排序,就是让集合构造方法接收Comparator的实现类对象。

  • 重写方法时,一定要注意排序规则必须按照主要条件和次要条件来写。

    //Studen.java
    public class Student {
    private int age;
    private String name;

    public Student( String name,int age) {this.age = age;this.name = name;
    }public int getAge() {return age;
    }public void setAge(int age) {this.age = age;
    }public String getName() {return name;
    }public void setName(String name) {this.name = name;
    }
    

    }

    //TreeSetDemo.java
    import java.util.TreeSet;
    import java.util.Comparator;
    public class TreeSetDemo {
    public static void main(String[] args) {
    TreeSet treeSet=new TreeSet(new Comparator(){
    @Override
    public int compare(Student s1,Student s2){
    int num=s1.getAge()-s2.getAge();
    int num1=(0==num?s1.getName().compareTo(s2.getName()):num);

                return num1;}});Student s1=new Student("aaa",25);Student s2=new Student("bbb",19);Student s3=new Student("ddd",20);Student s4=new Student("ccc",20);treeSet.add(s1);treeSet.add(s2);treeSet.add(s3);treeSet.add(s4);for(Student s:treeSet){System.out.println(s.getName()+","+s.getAge());}
    }
    

    }

3.4、泛型

3.4.1、泛型概述
  • JDK5中引入的特性。

  • 它提供了编译时类型安全检测机制,该机制允许在编译时检测到非法的类型,它的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。

  • 泛型类、泛型方法、泛型接口。

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

    public class GenericDemo {
    public static void main(String[] args) {
    Collection c=new ArrayList();
    c.add(“Hello”);
    c.add(“world”);
    Iterator it=c.iterator();
    while(it.hasNext()){
    String s = it.next();
    System.out.println(s);
    }
    }
    }

3.4.2、泛型类

泛型的定义格式:

  • 格式:修饰符 class 类名<类型>{}

  • 范例:public class Generic<T> {}
    此处T可以随便定为任意标识,常见的如TEKV

    //Generic.java
    public class Generic {
    private T t;

    public Generic(T t) {this.t = t;
    }public T getT() {return t;
    }public void setT(T t) {this.t = t;
    }
    

    }

    GenericDemo.java
    public class GenericDemo {
    public static void main(String[] args) {
    Generic g1=new Generic(“李淳罡”);
    System.out.println(g1.getT());
    Generic g2=new Generic(20);
    System.out.println(g2.getT());
    }

    }

3.4.3、泛型方法

泛型方法定义格式:

  • 格式:修饰符<类型> 返回值类型 方法名(类型 变量名){}

  • 范例:pubcli <T> void show(T t){}

    public class Generic{
    public void show(T t){
    System.out.println(t);
    }
    }

泛型方法改进:

public class Generic{public<T> void show(T t){System.out.println(t);}
}
3.4.4、泛型接口

泛型接口定义格式:

  • 格式:修饰符 interface 接口名<类型>{}

  • 范例:pubcli interface Generic<T>{}

    public interface Generic {
    void show(T t);
    }

    public class Genericlmpl implements Generic {
    @Override
    public void show(T t){
    System.out.println(t);
    }
    }

    public class Demo {
    public static void main(String[] args) {
    Generic g1=new Genericlmpl();
    g1.show(“hello”);
    Generic g2=new Genericlmpl();
    g2.show(15);
    }
    }

3.4.5、类型通配符

类型通配符

  • 为了表示各种泛型List的父类,可以使用类型通配符
  • 类型通配符:<?>
  • List<?>:表示元素类型未知的List,它的元素可以匹配任何的类型
  • 这种带通配符的List仅表示它是各种泛型List的父类,并不能把元素添加到其中。

类型通配符上限
如果不希望List<?>是任何泛型List的父类,只希望它代表某一类型泛型List的父类,可以使用类型通配符的上限。

  • 类型通配符上限:<extends 类型>
  • List<? extends Number>:它表示的类型是Number或者其子类型

类型通配符下限
除了可以指定类型通配符的上限,还可指定类型通配符的下限

  • 类型通配符下限:<? super 类型>

  • List<? super Number>:它表示的类型是Number或者其父类型
    在这里插入图片描述

    import java.util.List;
    import java.util.ArrayList;
    public class Demo {
    public static void main(String[] args) {
    //类型通配符:<?> List<?> list1=new ArrayList();
    List<?> list2=new ArrayList(); List<?> list3=new ArrayList();
    System.out.println(““);
    //通配符上限:<? extends 类型>
    // List<? extends Number> list4=new List();//报错,这里超过了上限
    List<? extends Number> list5=new ArrayList();
    List<? extends Number> List6=new ArrayList();
    System.out.println(”
    ”);
    //通配符下限:<? super 类型>
    List<? super Number> list7=new ArrayList();
    List<? super Number> list8=new ArrayList();
    // List<? super Number> list9=new ArrayList();//报错,这里超过了下限

    }
    

    }

3.4.6、可变参数
  • 格式:修饰符 返回值类型 方法名(数据类型... 变量名){}

  • 范例:public static int sum(int... a)

    public class Demo {
    public static void main(String[] args) {
    System.out.println(sum(1));
    System.out.println(sum(1,2));
    System.out.println(sum(1,2,3));
    }
    public static int sum(int… arr){
    int total=0;
    for(int i:arr){
    total+=i;
    }
    return total;
    }
    }

注意:

  • 这里的变量a其实是一个数组

  • 如果一个方法有多个参数,可变参数要放在最后。

    public static int sum(int a,int... arr){return 0;
    }  
    
3.4.7、可变参数的使用

Arrays工具类中有一个静态方法:

  • public static<T> List<T> asList(T... a):返回由指定数组支持的固定大小的列表。

  • 返回的集合不能做增删操作(增删会改变长度),可以做修改操作。

    import java.util.Arrays;
    import java.util.List;	
    public class Demo {public static void main(String[] args) {List<String> list= Arrays.asList("hello","world","java","hello");
    //        list.add("aaa");//UnsupportedOperationException
    //        list.remove("hello");//UnsupportedOperationExceptionlist.set(1,"aaa");System.out.println(list);}
    }
    

List接品中有一个静态方法:

  • public static<E> List<E> of(E... elements):返回包含任意数量元素的不可变列表。

  • 返回的集合不能做增删改操作。

    import java.util.List;public class Demo {public static void main(String[] args) {List<String> list= List.of("hello","world","hello");
    //        list.add("aaa");//UnsupportedOperationException
    //        list.remove("hello");//UnsupportedOperationException
    //        list.set(1,"aaa");//UnsupportedOperationExceptionSystem.out.println(list);}
    }
    

Set接口中有一个静太方法:

  • public static<E> Set<E> of(E... elements):返回一个包含任意数量元素的不可变集合。

  • 不能给重复的元素。

  • 返回的集合不能做增删操作,没有修改的方法。

    import java.util.Set;public class Demo {public static void main(String[] args) {
    //        Set<String> set= Set.of("hello","world","hello");//IllegalArgumentException,set中不能有重复元素Set<String> set= Set.of("hello","world");
    //        set.add("aaa");//UnsupportedOperationException
    //        set.remove("hello");//UnsupportedOperationExceptionSystem.out.println(set);}
    }
    

3.5、Map

3.5.1、Map集合概述

Map集合概述

  • Interface Map<k,v> K:键的类型; V:值的类型。
  • 将键映射到值的对象;
  • 不能包含重复的键;
  • 每个键可以映射到最多一个值。

创建Map集合对象

  • 多态的方式

  • 具体实现类HashMap

    import java.util.HashMap;
    import java.util.Map;

    public class MapDemo {
    public static void main(String[] args) {
    Map<String,String> map=new HashMap<String,String>();
    map.put(“001”,“唐僧”);
    map.put(“002”,“孙悟空”);
    map.put(“003”,“猪八戒”);
    map.put(“003”,“沙悟净”);//key重复,会被新的value覆盖
    System.out.println(map);
    }
    }

3.5.2、Map集合的基本功能

方法名

说明

V put(K key,V value)

添加元素

V remove(Object key)

根据键删除键值对元素

void clear()

移除所有的键值对元素

boolean containsKey(Object key)

判断集合是否包含指定的键

boolean containsValue(Object value)

判断集合是否包含指定的值

boolean isEmpty()

判断集合是否为空

int size()

集合的长度,即集合中键值对的个数

3.5.3、Map集合的获取功能

方法名

说明

V get(Object key)

根据键获取值

Set<K> keySet()

获取所有键的集合

Collection<V> values()

获取所有值的集合

Set<Map.Entry<K,v>> entrySet()

获取所有键值对对象的集合

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;public class MapDemo {public static void main(String[] args) {Map<String,String> map=new HashMap<String,String>();map.put("张无忌","赵敏");map.put("郭靖","黄蓉");map.put("杨过","小龙女");System.out.println(map.get("杨过"));System.out.println("*************");Set<String> set=map.keySet();for(String key:set){System.out.println(key);}System.out.println("*************");Collection<String> values=map.values();for(String value:values){System.out.println(value);}System.out.println("*************");System.out.println(map);}
}
3.5.4、Map集合的遍历

方式一:

import java.util.HashMap;
import java.util.Map;
import java.util.Set;public class MapDemo {public static void main(String[] args) {Map<String,String> map=new HashMap<String,String>();map.put("张无忌","赵敏");map.put("郭靖","黄蓉");map.put("杨过","小龙女");//获取所有键的集合Set<String> keys = map.keySet();for(String key:keys){String value=map.get(key);System.out.println(key+","+value);}}
}

方式二:

import java.util.HashMap;
import java.util.Map;
import java.util.Set;public class MapDemo {public static void main(String[] args) {Map<String,String> map=new HashMap<String,String>();map.put("张无忌","赵敏");map.put("郭靖","黄蓉");map.put("杨过","小龙女");Set<Map.Entry<String, String>> entries = map.entrySet();for(Map.Entry<String,String> entry:entries){String key=entry.getKey();String value=entry.getValue();System.out.println(key+","+value);}}
}
3.5.5、HashMap的案例
  • 创建一个HashMap集合,键是学生对象(Student),值是居住地(String)

  • 要求保证唯一性:若学生对象成员变量值相同,认为是同一对象。

    //Student.java
    public class Student {
    private String name;
    private int age;

    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;if (age != student.age) return false;return name != null ? name.equals(student.name) : student.name == null;
    }@Override
    public int hashCode() {int result = name != null ? name.hashCode() : 0;result = 31 * result + age;return result;
    }
    

    }

    //HashMapDemo.java
    import java.util.HashMap;
    import java.util.Set;

    public class HashMapDemo {
    public static void main(String[] args) {
    HashMap<Student,String> hm=new HashMap<Student,String>();

        Student s1=new Student("孙悟空",30);Student s2=new Student("猪八戒",20);Student s3=new Student("沙悟净",20);Student s4=new Student("孙悟空",30);/*s1和s4对象相同,value应该被覆盖若要s1和s4对象相同,须重写Student类的hashCode和equals*/hm.put(s1,"花果山");hm.put(s2,"高老庄");hm.put(s3,"流沙河");hm.put(s4,"水帘洞");//遍历Set<Student> students = hm.keySet();for(Student s:students){String value=hm.get(s);System.out.println(s.getName()+","+s.getAge()+",住在"+value);}}
    

    }

3.5.6、ArrayList中嵌套HashMap
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;public class ArrayListIncludeHashMap {public static void main(String[] args) {ArrayList<HashMap<String,String>> arrList=new ArrayList<HashMap<String,String>>();HashMap<String,String> hm1=new HashMap<String,String>();hm1.put("郭靖","黄蓉");hm1.put("杨过","小龙女");HashMap<String,String> hm2=new HashMap<String,String>();hm2.put("吕布","貂蝉");hm2.put("诸葛亮","黄月英");HashMap<String,String> hm3=new HashMap<String,String>();hm3.put("张无忌","赵敏");hm3.put("宋青书","周芷若");arrList.add(hm2);arrList.add(hm2);arrList.add(hm3);for(HashMap<String,String> hm:arrList){Set<String> keySet = hm.keySet();for(String key:keySet){String value=hm.get(key);System.out.println(key+","+value);}System.out.println("************");}}
}
3.5.7、HashMap中嵌套ArrayList
3.5.8、统计字符串中每个字符出现的次数

需求:

  • 键盘录入一个字符串,统计字符串中每个字符出现的次数。
  • 举例:录入"aabbccdd"在控制台输出“a(2)b(2)c(2)”

思路:

  • 键盘录入一个字符串

  • 创建HashMap集合,键是Character,值是Integer

  • 遍历字符串,得到每一个字符。

    import java.util.Map;
    import java.util.Scanner;
    import java.util.Set;
    import java.util.TreeMap;

    public class Demo {
    public static void main(String[] args) {
    Scanner sc=new Scanner(System.in);
    System.out.println(“请输入一个字符串”);
    String line = sc.nextLine();
    Map<Character,Integer> map=new TreeMap<Character,Integer>();
    //遍历字符串,得到每一个字符
    for(int i=0;i<line.length();i++){
    char key=line.charAt(i);
    Integer value=map.get(key);
    if(null==value){
    map.put(key,1);
    }else{
    value++;
    map.put(key,value);
    }
    }

        //遍历HashMap集合StringBuilder sb=new StringBuilder();Set<Character> keySet = map.keySet();for(Character key:keySet){Integer value=map.get(key);sb.append(key).append("(").append(value).append(")");}System.out.println(sb.toString());
    }
    

    }

3.6、Collections

3.6.1、Collections的概述
  • 是针对集合操作的工具类。

常用方法

  • public static <T extends Comparable<? super T>> void sort(List<T> list):将指定的列表按升序排序。

  • public static void reverse(List<?> list):反转指定列表中元素的顺序。

  • public static void shuffle(List<?> list):使用默认的随机源随机排列指定的列表。

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

    public class CollectionsDemo {
    public static void main(String[] args) {
    List list=new ArrayList();

        list.add(3);list.add(4);list.add(1);list.add(6);list.add(5);list.add(2);//排序Collections.sort(list);System.out.println(list);//反转list中的顺序Collections.reverse(list);System.out.println(list);//洗牌Collections.shuffle(list);System.out.println(list);
    }
    

    }

3.6.2、对ArrayList排序
public class Student {private String name;private int age;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;}
}java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;public class Demo {public static void main(String[] args) {ArrayList<Student> array=new ArrayList<Student>();Student s1=new Student("linqingxia",30);Student s2=new Student("zhangmanyu",35);Student s3=new Student("aaaaa",33);Student s4=new Student("bbbb",33);array.add(s1);array.add(s2);array.add(s3);array.add(s4);//使用Collectons对ArrayList集合排序Collections.sort(array, new Comparator<Student>() {@Overridepublic int compare(Student s1, Student s2) {//按照年龄排序int num=s1.getAge()-s2.getAge();int num2=num==0?s1.getName().compareTo(s2.getName()):num;return num2;}});for(Student s:array){System.out.println(s.getName()+","+s.getAge());}

相关文章:

Java入门进阶

文章目录 1、常用API 1.1、Math1.2、System1.3、Object1.4、Arrays1.5、基本类型包装类 1.5.1、基本类型包装类概述1.5.2、Integer1.5.3、int和String相互转换1.5.4、自动装箱和拆箱 1.6、日期类 1.6.1、Date类1.6.2、SimpleDateFormat类 1.6.2.1、格式化&#xff08;从Date到…...

Java并发编程面试题:ThreadLocal(8题)

&#x1f9d1; 博主简介&#xff1a;CSDN博客专家&#xff0c;历代文学网&#xff08;PC端可以访问&#xff1a;https://literature.sinhy.com/#/?__c1000&#xff0c;移动端可微信小程序搜索“历代文学”&#xff09;总架构师&#xff0c;15年工作经验&#xff0c;精通Java编…...

Zabbix7.0安装(Ubuntu24.04+LNMP)

1.选择版本 下载Zabbix 2.安装虚拟机 这里选择在Ubuntu24.04上安装Zabbix. 安装链接https://blog.csdn.net/weixin_58189050/article/details/145446065 配置源 vim /etc/apt/sources.list deb https://mirrors.aliyun.com/ubuntu/ noble main restricted universe multive…...

从 0 到 1 构建数仓之DWD层

在企业数字化转型进程中&#xff0c;数据仓库的建设至关重要&#xff0c;而 DWD 层&#xff08;明细粒度事实层&#xff09;作为数据仓库的核心支撑层&#xff0c;其搭建质量直接影响企业数据的分析价值与决策效率。本文将结合实际案例与行业经验&#xff0c;详细阐述企业如何从…...

S4 HANA手工记账Tax Payable – FB41

本文主要介绍在S4 HANA OP中手工记账Tax Payable – FB41。具体请参照如下内容&#xff1a; 手工记账Tax Payable – FB41 该事务代码用于手工处理税码统驭科目的记账&#xff0c;一般税码科目需要设置为只能自动记账&#xff0c;因此无法手工对税码统驭科目记账&#xff0c;但…...

【自然语言处理(NLP)】NLP实战:IMDB影评情感分析项目

文章目录 介绍IMDB影评情感分析项目数据集项目实现1. 导包2. 加载IMDB数据3. 查看部分数据4. 分词5. 加载数据整合6. 构建模型7. 词嵌入8. 初始化模型和权重9. glove词向量10. 训练和评估11. 预测 个人主页&#xff1a;道友老李 欢迎加入社区&#xff1a;道友老李的学习社区 介…...

DIY Shell:探秘进程构建与命令解析的核心原理

个人主页&#xff1a;chian-ocean 文章专栏-Linux 前言&#xff1a; Shell&#xff08;外壳&#xff09;是一个操作系统的用户界面&#xff0c;它提供了一种方式&#xff0c;使得用户能够与操作系统进行交互。Shell 是用户与操作系统之间的桥梁&#xff0c;允许用户通过命令行…...

通过Redisson构建延时队列并实现注解式消费

目录 一、序言二、延迟队列实现1、Redisson延时消息监听注解和消息体2、Redisson延时消息发布器3、Redisson延时消息监听处理器 三、测试用例四、结语 一、序言 两个月前接了一个4万的私活&#xff0c;做一个线上商城小程序&#xff0c;在交易过程中不可避免的一个问题就是用户…...

SQL Server配置管理器无法连接到 WMI 提供程序

目录 第一步第二部 第一步 发现没有资源管理器 ​​​​ 在文件夹找到管理器 打开发现报这个错误 配置管理器无法连接到 WMI 提供程序第二部 https://blog.csdn.net/thb369208315/article/details/126954074...

Linux内核源码:ext4 extent详解

在 Linux 系统的庞大体系中&#xff0c;文件系统就像是一个井然有序的图书馆&#xff0c;而 ext4 文件系统则是这座图书馆中极为重要的 “藏书室”&#xff0c;它负责高效管理和存储数据。在 ext4 众多的奥秘中&#xff0c;ext4 extent 犹如一颗璀璨的明珠&#xff0c;起着关键…...

Maven jar 包下载失败问题处理

Maven jar 包下载失败问题处理 1.配置好国内的Maven源2.重新下载3. 其他问题 1.配置好国内的Maven源 打开⾃⼰的 Idea 检测 Maven 的配置是否正确&#xff0c;正确的配置如下图所示&#xff1a; 检查项⼀共有两个&#xff1a; 确认右边的两个勾已经选中&#xff0c;如果没有请…...

自指学习:AGI的元认知突破

文章目录 引言:从模式识别到认知革命一、自指学习的理论框架1.1 自指系统的数学定义1.2 认知架构的三重反射1.3 与传统元学习的本质区别二、元认知突破的技术路径2.1 自指神经网络架构2.2 认知效能评价体系2.3 知识表示的革命三、实现突破的关键挑战3.1 认知闭环的稳定性3.2 计…...

排序算法--希尔排序

希尔排序是插入排序的改进版本&#xff0c;适合中等规模数据排序&#xff0c;性能优于简单插入排序。 // 希尔排序函数 void shellSort(int arr[], int n) {// 初始间隔&#xff08;gap&#xff09;为数组长度的一半&#xff0c;逐步缩小for (int gap n / 2; gap > 0; gap …...

Java 2024年面试总结(持续更新)

目录 最近趁着金三银四面了五六家公司吧&#xff0c;也整理了一些问题供大家参考一下&#xff08;适合经验三年左右的&#xff09;。 面试问题&#xff08;答案是我自己总结的&#xff0c;不一定正确&#xff09;&#xff1a; 总结&#xff1a; 最近趁着金三银四面了五六家公…...

TensorFlow是个啥玩意?

TensorFlow是一个开源的机器学习框架&#xff0c;由Google开发。它可以帮助开发者构建和训练各种机器学习模型&#xff0c;包括神经网络和深度学习模型。TensorFlow的设计理念是使用数据流图来表示计算过程&#xff0c;其中节点表示数学运算&#xff0c;边表示数据流动。 Tens…...

不可信的搜索路径(CWE-426)

漏洞描述&#xff1a;程序使用关键资源时&#xff08;如动态链接库、执行文件、配置文件等&#xff09;没有明确的指定资源的路径&#xff0c;而是依赖操作系统去搜索资源&#xff0c;这种行为可能被攻击者利用&#xff0c;通过在搜索优先级较高的目录放置不良资源&#xff0c;…...

Linux——基础命令

$&#xff1a;普通用户 #&#xff1a;超级用户 cd 切换目录 cd 目录 &#xff08;进入目录&#xff09; cd ../ &#xff08;返回上一级目录&#xff09; cd ~ &#xff08;切换到当前用户的家目录&#xff09; cd - &#xff08;返回上次目录&#xff09; pwd 输出当前目…...

利用TensorFlow.js实现浏览器端机器学习:一个全面指南

引言 随着深度学习技术的不断发展&#xff0c;机器学习已从传统的服务器端运算逐渐转向了前端技术。TensorFlow.js 是 Google 推出的一个用于在浏览器中进行机器学习的开源库&#xff0c;它允许开发者在浏览器中直接运行机器学习模型&#xff0c;而无需依赖后端服务器。Tensor…...

利用HTML和css技术编写学校官网页面

目录 一&#xff0c;图例展示 二&#xff0c;代码说明 1&#xff0c;html部分&#xff1a; 【第一张图片】 【第二张图片】 【第三张图片】 2&#xff0c;css部分&#xff1a; 【第一张图片】 【第二张图片】 【第三张图片】 三&#xff0c;程序代码 一&#xff0c;…...

SpringSecurity密码编码器:使用BCrypt算法加密、自定义密码编码器

1、Spring Security 密码编码器 Spring Security 作为一个功能完备的安全性框架,一方面提供用于完成加密操作的 PasswordEncoder 组件,另一方面提供一个可以在应用程序中独立使用的密码模块。 1.1 PasswordEncoder 抽象接口 在 Spring Security 中,PasswordEncoder 接口代…...

笔记:新能源汽车零部件功率级测试怎么进行?

摘要:本文旨在梳理主机厂对新能源汽车核心零部件功率级测试需求,通过试验室的主流设备仪器集成,快速实现试验方案搭建,并体现测试测量方案的时效性、便捷性优势。目标是通过提升实现设备的有效集成能力、实现多设备测试过程的有效协同、流程化测试,可快速采集、分析当前数…...

ES6中的map和原生的对象有什么区别?

在 ES6 中&#xff0c;Map 和原生的对象&#xff08;Object&#xff09;都是用来存储键值对数据的集合&#xff0c;但它们有显著的区别。以下是它们之间的主要区别&#xff1a; 1. 键的类型 Object: 只允许使用字符串或符号作为键。其他类型的键&#xff08;如数字或对象&…...

2502vim,vim文本对象中文文档

介绍 文本块用户(textobj-user)是一个可帮助你毫不费力地创建自己的文本对象的Vim插件. 因为有许多陷阱需要处理,很难创建文本对象.此插件隐藏了此类细节,并提供了声明式定义文本对象的方法. 你可用正则式来定义简单的文本对象,或使用函数来定义复杂的文本对象.如… 文本对…...

spring security与gateway结合进行网关鉴权和授权

在Spring Cloud Gateway中集成Spring Security 6以实现鉴权和认证工作&#xff0c;可以在网关代理层完成权限校验和认证。这种架构通常被称为“边缘安全”或“API网关安全”&#xff0c;它允许你在请求到达后端服务之前进行集中式的安全控制。 以下是如何配置Spring Cloud Gat…...

LabVIEW在电机自动化生产线中的实时数据采集与生产过程监控

在电机自动化生产线中&#xff0c;实时数据采集与生产过程监控是确保生产效率和产品质量的重要环节。LabVIEW作为一种强大的图形化编程平台&#xff0c;可以有效实现数据采集、实时监控和自动化控制。详细探讨如何利用LabVIEW实现这一目标&#xff0c;包括硬件选择、软件架构设…...

log4j2日志配置文件

log4j2配置文件每个项目都会用到,记录一个比较好用的配置文件,方便以后使用时调取,日志输出级别为debug,也可以修改 <?xml version"1.0" encoding"UTF-8"?> <Configuration monitorInterval"180" packages""><prope…...

用Deepseek做EXCLE文件对比

背景是我想对比两个PO系统里的一个消息映射&#xff0c;EDI接口的mapping有多复杂懂的都懂&#xff0c;它还不支持跨系统版本对比&#xff0c;所以我费半天劲装NWDS&#xff0c;导出MM到excle&#xff0c;然后问题来了&#xff0c;我需要对比两个excel文件里的内容&#xff0c;…...

Tailwind CSS v4.0 升级与 Astro 5.2 项目迁移记录

本文博客链接 https://ysx.cosine.ren/tailwind-update-v4-migrate 自用小记。 Tailwind CSS v4.0 - Tailwind CSS 新的高性能引擎 - 完整构建的速度速度快 5 倍&#xff0c;增量构建的速度快于 100 倍以上 —— 以微秒为单位进行测量。为现代 Web 设计 - 建立在前沿的 CSS 特…...

TongSearch3.0.4.0安装和使用指引(by lqw)

文章目录 安装准备手册说明支持的数据类型安装控制台安装单节点(如需集群请跳过这一节)解压和启动开启X-Pack Security和生成p12证书&#xff08;之后配置内置密码和ssl要用到&#xff09;配置内置用户密码配置ssl&#xff08;先配置内置用户密码再配ssl&#xff09;配置控制台…...

低代码产品表单渲染架构

在React和Vue没有流行起来的时候&#xff0c;低代码产品的表单渲染设计通常会使用操作Dom的方式实现。 下面是一个表单的例子&#xff1a; 产品层 用户通过打开表单&#xff0c;使用不同业务场景业务下的表单页面&#xff0c;中间的Render层就是技术实现。 每一个不同业务的表单…...