包--package

分包

实际开发中,用的都是多级包(不同的包下放不同的代码)

公司域名反写(中间加"."隔开)

包名:

service------业务层代码:逻辑判断

dao(data access object)-----数据访问层代码

pojo/entity/domain------一些实体类(放事物的一些属性)

test------测试类(main方法所在)

control/web------前后端交互

权限修饰符的范围

形式参数:类,具体类或者抽象类 接 口以及返回值问题--->具体类/抽象 类/接口类型

形式参数:

情况1:方法的形式参数是一个具体类,调用该方法实际参数如何传递

需要传递一个具体的类对象

 代码体现

class Student{
public void study(){
System.out.println("学习JavaEE之JavaSE基础");
}
}
class StudentDemo{
public void method(Student student){//形式参数一个引用类型:具体类,调用该
方法,实际参数需要一个学生对象
student.study() ;
}
}
//测试类中测试
//调用StudentDemo类的method方法
//创建StudentDemo类对象
StudentDemo sd = new StudentDemo() ;
//调用该方法,实际参数需要一个学生对象
Student s = new Student() ;
sd.method(s); //实际参数s

情况2:方法的形式参数是一个抽象类,调用该方法实际参数如何传递

传递一个抽象类的具体的子类对象

代码体现

abstract class Person{//人类
public abstract void work(); //工作
}
class PersonDemo{
//成员方法
public void show(Person p){//形式参数是一个抽象类,抽象类不能实例化,需要
new 它的子类对象 抽象类多态
p.work() ;
}
}
//必须提供子类
//只能现在提供抽象类的具体的子类
class Worker extends Person{
@Override
public void work() {
System.out.println("爱生活,爱工作,爱高圆圆");
}
}
//测试类中测试
PersonDemo pd = new PersonDemo() ;
//创建Person对象
//Person p = new Person(); 抽象类不能实例化
// pd.show(p);
//抽象类多态
Person p = new Worker() ;
pd.show(p);
System.out.println("-----------------------------------------");
//匿名对象
pd.show(new Worker());

情况3: 方法的形式参数是一个接口,调用该方法实际参数如何传递

实际参数传递的是该接口的子实现类对象

代码体现

interface Love{
void love() ;
}
class LoveDemo{
public void function(Love lo){ //方法形式参数是一个接口类型,接口new不了
lo.love();
}
}
//需要提供具体的子实现类
class LoveImpl implements Love{
@Override
public void love() {
System.out.println("love loveImpl...");
}
}
//测试类中测试
//调用LoveDemo类的中的function方法
//创建LoveDemo类对象
LoveDemo ld = new LoveDemo() ;
//创建Love对象
//Love love = new Love() ;//接口不能实例化,肯定需要接口的子实现类
//ld.function(love);
//接口多态的方式:接口名 对象名 = new 具体的子实现类名() ;
Love love = new LoveImpl() ;
ld.function(love);
//方式2:
ld.function(new LoveImpl()) ;

返回值问题

情况1 方法返回值类型是一个具体类,如何返回

需要返回当前类的具体类对象

代码体现

//学生类
class Student{
public void study(){
System.out.println("正在学习JavaEE");
}
}
//StudentDemo
class StudentDemo{
public Student method(){//这个的返回值是一个引用类型,具体类---方法结束,
必须返回一个当前类的具体类对象
// 如何结束???
//return Student;
//方式1 :
/*Student s = new Student() ;
return s;*/
//方式2:匿名对象的格式
return new Student() ;
}
}
//测试类
//调用StudentDemo这个类里面的method方法
StudentDemo sd = new StudentDemo() ;
Student s = sd.method(); // 这个方法的本质: new Student();
s.study() ;

情况2: 方法返回值类型是一个抽象类, 如何返回

返回的是该抽象类的子类对象

代码体现

//抽象类
abstract class Person{
public abstract void work();
}
class PersonDemo {
public Person show(){ //方法的返回值是一个抽象类,必须要提供抽象类子类
//??
/* Person p = new Person() ;//抽象类不能new
return p ;*/
//return new Person() ;
//需要抽象类的子类对象:抽象类多态
//方式1:抽象类多态
/* Person p = new Programmer() ;
return p;*/
//方式2:匿名对象
return new Programmer() ;
}
}
//需要有抽象类的子类,才能使用抽象类多态
class Programmer extends Person{ //程序员类是具体的子类
@Override
public void work() {
System.out.println("不断的去完成项目开发...");
}
}
//测试类中测试
//调用PersonDemo的show方法
PersonDemo pd = new PersonDemo() ;
Person person = pd.show(); //show方法本质 new Programmer() ;
person.work();

情况3:方法返回值类型是一个接口,如何返回

返回的是该接口的子实现类对象

代码体现

//定义一个接口
interface Mary{
void mary() ;
}
//定义一个类
class MaryDemo{
public Mary method(){ //方法的返回值是接口类型,接口实例化不了的!
//??
//Mary mary = new Mary() ;
// return mary ;
//return new Mary() ;
//方式1:接口多态
// Mary mary = new WeddingCompany() ;
//return mary ;
//方式2:匿名对象
return new WeddingCompany() ;
}
}
//需要接口的子实现类
//婚庆公司
class WeddingCompany implements Mary{
@Override
public void mary() {
System.out.println("婚庆公司布置婚礼现场!");
}
}
//测试类中测试
MaryDemo maryDemo = new MaryDemo() ;
Mary m = maryDemo.method();//method方法本质:创建子实现类对象 new
WeddingCompany() ;
m.mary();

类及其组成可以用的修饰符

内部类

定义:在类中创建的类

位置

按照内部类在类中定义的位置不同，可以分为如下两种格式：

成员位置(成员内部类):即类中方法外

局部位置(局部内部类):即方法定义上或方法中

成员内部类 外界如何创建对象

外部类名.内部类名 对象名 = 外部类对象.内部类对象;

成员内部类

成员内部的常见修饰符

private 为了保证数据的安全性

static 为了让数据访问更方便

被静态修饰的成员内部类只能访问外部类的静态成员

内部类被静态修饰后的方法 可以是静态方法，也可以是非静态方

面试题

补齐程序(注意:内部类和外部类没有继承关系)
class Outer {public int num = 10;class Inner {public int num = 20;public void show() {int num = 30;//补全代码}}
}
在控制分别输出：30，20，10

//答案:
System.out.println(num);
System.out.println(this.num);
System.out.println(Outer.this.num);

局部内部类

可以直接访问外部类的成员

可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能

注意事项 

局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还 要使用那个变量。为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实 是一个常量值。

代码体现 

class Outer {public void method() {final int n = 100;class Inner {public void show() {System.out.println(n);}}Inner i = new Inner();i.show();}
}
class OuterDemo {public static void main(String[] args) {Outer o = new Outer();o.method();}
}

匿名内部类 

内部类的简化写法

前提 

存在一个类或者接口

这里的类可以是具体类也可以是抽象类。

格式

new 类名或者接口名() {重写方法;}

本质

是一个继承了类或者实现了接口的子类匿名对象

代码体现 

abstract class Person {public abstract void show();
}
class PersonDemo {public void method(Person p) {s.show();}
}class PersonTest {public static void main(String[] args) {//如何调用PersonDemo中的method方法呢?PersonDemo pd = new PersonDemo ();pd.method(new Person() {public void show() {System.out.println(“show”);}});}
}

面试题

interface Inter { void show(); }
class Outer { //补齐代码 }
class OuterDemo {public static void main(String[] args) {Outer.method().show();
}
}
要求在控制台输出”HelloWorld//答案
public static Inter method(){return new Inter() {@Overridepublic void show() {System.out.println("helloworld");}};}

常用类

Object类

Object类是所有类的根类,所有类的超类也就是父类

重点功能 

public String toString()

// 返回对象的字符串表示形式。 一般来说， toString方法返回一个“textually代表”这个对象的字符串。 结果应该是一个简 明扼要的表达，容易让人阅读。 建议所有子类覆盖此方法

public int hashCode()      //返回对象的哈希码值

public boolean equals(Object obj)     //指示一些其他对象是否等于此

protected Object clone() throws CloneNotSupportedException     //创建并返回此对象的副本

String类

特点

字符串的值在创建后不能被更改

因为String对象是不可变的，所以它们可以被共享。

 常用功能

面试题 

*String s1 = "hello" ;
* String s2 = new String("hello") ;
* 他们分别创建了几个对象,有什么区别呢?
* s1: 现在常量池中,是否存在这个常量,如果存在,直接返回地址值;否则,开辟新的空间地址值,赋值s1
* s2:在堆内存中申请空间,然后常量"hello",
* 还需要在常量池中找是否存在这个常量,有,就返回地址,重新开辟常量池空间
*
*
* 共同点:都表示创建"hello"字符串实

 StringBuffer类

线程安全的可变字符序列

常用功能

int length(): 获取字符串缓冲区的长度
public int capacity():获取字符串缓冲区的容量 默认容量 16个字符,超过这个容量,会自己分配,使用的新的字符串的长度+16
StringBuffer常用的功能
public StringBuffer append(任意类型数据):添加任何类型数据到字符串缓冲区中
返回值字符串缓冲区本身
public StringBuffer insert(int offset,String xx):插入:在指定位置的前面插入一个新的字符序列
public StringBuffer reverse():将字符串缓冲区字符序列反转

面试题 StringBuffer和String 的区别

String的特点:字符串常量,一旦创建,其值不改变; 不支持可变的字符序列

StringBuffer:支持的可变的字符序列,而且线程安全的,---执行效率低,多线程环境会 用,单线程环境下用的StringBuilder这个类;

方法的形式参数:

String和基本类型效果一样;形式参数的改变不影响实际参数

StringBuffer:作为方法的形式参数,形式参数的改变,直接影响实际参数

类型转换

/**
* 类型转换
* StringBuffer和String的类型转换
*
* String---->StringBuffer,目的为了StringBuffer的特有功能
* StringBuffer--->String,结果需要是String类型
*/
public class StringBufferDemo3 {
public static void main(String[] args) {
//String----StringBuffer
//有一个字符串
String s = "hello" ;
//StringBuffer sb = s;
//方式1:利用StringBuffer()无参构造方法+append(String str)
//创建一个字符串缓冲区对象
StringBuffer sb = new StringBuffer() ;
sb.append(s) ;
System.out.println(sb); //字符串缓冲区存储的数据内容 "hello",类型是
StringBuffer
System.out.println("----------------------------------");
//方式2:利用StringBuffered的有参构造方法StringBuffer(String str)
StringBuffer sb2 = new StringBuffer(s) ;
System.out.println(sb2);
System.out.println("-----------------------StringBuffer转换成String--
---------------------");
//StringBuffer --->String
StringBuffer buffer = new StringBuffer("helloworld") ;//字符序列是
helloworld,外面的类型StringBuffer
//方式1:public String(StringBuffer buffer) ;String类的构造方法
String str = new String(buffer) ;
System.out.println(str) ; //内容"helloworld",类型String
System.out.println("-------------------------------------");
//方式2:public String toString() 显示的应该是字符串缓冲区中的实际的
字符序列内容
String str2 = buffer.toString();
System.out.println(str2);
/*int i = 100 ;
String s4 = "100" ;*/
}
}

Integer类

自动拆装箱

/**
* Integer类的构造方法
* public Integer(int value):将int类型----Integer类型
* public Integer(String s) throws NumberFormatException :将数字字符串
转换成Integer
* throws:抛出异常的意思
* 抛出异常的可能性,当你传入的字符串如果不是数字字
符串,jvm解析的时候,将这个异常就信息打印在控制台上
*
*
*/
public class IntegerDemo2 {
public static void main(String[] args) {
int i = 100 ;//基本类型
// public Integer(int value):将int类型----Integer类型
Integer ii = new Integer(i) ;
System.out.println(ii) ;//100
ii += 200 ;
System.out.println(ii);
//public Integer(String s) throws NumberFormatException :将数字字符
串 转换成Integer
//String s = "hello" ;//字符串: 必须是数字字符串 Integer是int类型包
装类型
/* String s = "20" ;
Integer iii = new Integer(s) ;
System.out.println(iii);*///20
}
/**
* 上面代码的使用反编译工具查看
* jdk5新特性:自动拆装箱 :基本类型--- 变成对应的引用类型 "装箱"
* 这些引用类型----->基本类型 ""拆箱
*
* int i = 100;
* Integer ii = new Integer(i); //装箱 int---->Integer
* System.out.println(ii);
*
* //我们的写的代码 ii+=200 ;
* //反编译工具---将 ii+=200:优化下面格式
*
* ii = Integer.valueOf(ii.intValue() + 200); //参数里面:
ii.intValue()+ 200 : ii--->拆箱 int类型 +200 求和
* //参数里面完成计算---->int结果
* public static Integer valueOf(int i) :将int类型的结果----
>Integer "装箱"
*
*
* System.out.println(ii);
*
*/
}

Integer内部缓存区 

/* 将一个常量值赋值给Integer类型,通过反编译工具 调用的Integer.valueOf(int类
型的值)
*/
public class IntegerTest {
public static void main(String[] args) {
Integer i1 = 127 ;
Integer i2 = 127 ;
System.out.println(i1==i2) ;//true
System.out.println(i1.equals(i2)) ;//true
Integer i3 = 127 ;
Integer i4 = new Integer(127) ;
System.out.println(i3==i4) ; //false
System.out.println(i3.equals(i4)) ;//true
//值128 超过-128-127
Integer i5 = 128 ; //Integer i5 = new Integer(128);
Integer i6 = 128 ; //Integer i6 = new Integer(128);
System.out.println(i5==i6) ; //false
System.out.println(i5.equals(i6)) ;//true
Integer i7 = new Integer(128) ;
Integer i8 = new Integer(128) ;
System.out.println(i7==i8) ;//false
System.out.println(i7.equals(i8)) ;//true
}
}

常用功能

构造方法:

        public Integer(int value)

public Integer(String s)

成员方法

        //int类型和String类型的相互转换

//int – String

//String – int

public int intValue()

public static int parseInt(String s)

public static String toString(int i)

public static Integer valueOf(int i)

public static Integer valueOf(String s)

//常用的基本进制转换

public static String toBinaryString(int i)

public static String toOctalString(int i)

public static String toHexString(int i

character类

常用功能

构造方法

public Character(char value)

成员方法

        public static boolean isUpperCase(char ch)

public static boolean isLowerCase(char ch)

public static boolean isDigit(char ch)

public static char toUpperCase(char ch)

public static char toLowerCase(char ch)

int和String的相互转换

/*基本数据类型:八种 如何转换String
* String---->基本类型
* 使用 int举例
*
* int---->String :Integer.valueOf(int类型的值)
* String---->int :Integer.parseInt(数字字符串)
*/
public class IntegerDemo3 {
public static void main(String[] args) {
//int---->String
int i = 10 ;
//方式1:字符串拼接 符号+
System.out.println(i+"");//"10"
//方式2:int---->Integer:装箱---->String
//Intege(int i)
Integer ii = new Integer(i) ;
//Integer---->String :public String toString()
String s = ii.toString();
System.out.println(s) ; //"10"
//方式3:Integer类的静态方法:public static String toString(int i) (推
荐)
String s2 = Integer.toString(i);
System.out.println(s2);
System.out.println("-----------------------------------------------")
;
//String --->int
String str = "100" ;// 数字字符串
//方式1:推荐 Integer 静态方法 public static int parseInt(String
str): "最常用的"
int number = Integer.parseInt(str);
System.out.println(number); //100
//方式2:String---->Integer--->int
//Integer(String s)
Integer integ = new Integer(str) ;
//public int intValue()
int number2 = integ.intValue();
System.out.println(number2) ;
}
}

Random类

常用功能

构造方法

        public Random()

public Random(long seed)

成员方法

        public int nextInt()

public int nextInt(int n)

System类

常用功能

public static void gc()

public static void exit(int status)

public static long currentTimeMillis()

public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)

Date,DateFormat类

DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。 是抽象类，所以使用其子类SimpleDateFormat

date类

public Date()

public Date(long date)

public long getTime()

public void setTime(long time)

SimpleDateFormat

        构造方法

                public SimpleDateFormat()

public SimpleDateFormat(String pattern)

成员方法

                      

Date和String的类型转换

/**
* Date重点:日期文本格式和Date如何转换?
* String日期文本格式 "2022-8-13"------>java.util.Date 日期格式
* Date日期格式 转换成 String
*
* 使用中间桥梁:DateFormat类 是一个抽象类,不能实例化,jdk提供更具体的子
类:SimpleDateFormat
*
* 构造方法
* public SimpleDateFormat(String pattern)
* yyyy:年 MM:月 dd:月中日期 HH:小时 mm:分钟 ss:秒
*
* 成员方法:
* Date---->String public String foramt(Date date) :格式化
*
* String--->Date: public Date parse(String dateStr) throws
ParseException: 解析
* 这个本身可能出现异常,如果解析的字符串的
格式和 pattern参数的模式匹配,就出错了,解析失败!
* public SimpleDateFormat(String pattern)
*
* String s = "2008-5-12" ;
* SimpleDateFormat sdf = new
SimpleDateFormat("yyyy年MM月dd日") ;
* SimpleDateFormat sdf = new
SimpleDateFormat("yyyy-MM-dd ") ;
*
*/
public class DateDemo2 {
public static void main(String[] args) throws ParseException {
//Date---->String :格式化操作
Date date = new Date() ; //创建当前系统时间日期对象
System.out.println(date);
//使用中间桥梁 public SimpleDateFormat(String pattern)
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd") ;
// public String foramt(Date date) :格式化
String s = sdf.format(date);
System.out.println(s);
System.out.println("-------------------------------------") ;
//String--->Date: public Date parse(String dateStr) throws
ParseException: 解析
String dataStr = "2008-5-12" ;
//创建中间桥梁 public SimpleDateFormat(String pattern)
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd") ;
//解析
Date d = sdf2.parse(dataStr);
System.out.println(d);
}
}

集合

数组和集合的区别?

1.长度的区别
数组长度固定
集合长度可变
2.存储数据类型的区别
数组:存储的数据类型:可以是基本数据类型,也可以是引用类型
集合:存储的数据类型:只能使用引用类型
3.存储元素的区别
数组:这个容器只能存储同一种类型的元素
集合:这个容器可以存储不同的引用类型的元素
```'
## Collection:集合的顶层次的根接口

Collection集合

常用功能 

boolean add(E e) 添加元素

boolean remove(Object o) 删除元素

boolean contains(Object o)判断是否包含指定的元素

Object[] toArray():将集合转换成对象数组

Iterator iterator():Collection集合的迭代器

Iterator iterator():判断集合是否为空

三种遍历方式代码体现

import java.util.*;public class CollectionTest {public static void main(String[] args) {Collection<Student> c=new ArrayList<>();Student s1=new Student("徐凤年",29);Student s2=new Student("姜泥",26);Student s3=new Student("徐龙象",23);Student s4=new Student("李淳罡",44);c.add(s1);c.add(s2);c.add(s3);c.add(s4);//方式一;转化为数组对象进行遍历Object[] obj=c.toArray();for(int i=0;i< obj.length;i++){System.out.println(obj[i]);}System.out.println("--------------------------------------");//方式二:运用collection迭代器Iterator<Student> it=c.iterator();while(it.hasNext()){System.out.println(it.next());}System.out.println("--------------------------------------");//方式三:增强for循环for(Student s:c){System.out.println(s);}}
}
//学生类
import java.util.Objects;public class Student {private String name;private int age;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic int hashCode() {return Objects.hash(name, age);}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;return age == student.age && name.equals(student.name);}}

List集合 (继承collection接口)

ArrayList:

底层数据结构是数组,查询快,增删慢,

线程角度考虑:线程不安全,不同步,执行效率高!

注意: 有扩容机制,是之前集合的1.5倍

Vcctor:

底层数据结构数组,查询快,增删慢,

线程角度考虑:线程安全的类,同步,执行效率低;

LinkedList:

底层数据结构是链表,查询慢,增删快

线程角度考虑:线程不安全的类,不同步,执行效率高

List接口成员方法

void add(int index,E element) 在指定位置处添加元素

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

E get(int index) 获取指定位置的元素

E set(int index,E element) 在指定位置设置指定的元素

ListIterator listIterator() 列表迭代器

ArrayList子实现类 (collection和list的子实现类)

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

代码体现 

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;public class ListTest {public static void main(String[] args) {//方式三运用list特有的方法进行遍历List<Student> list=new ArrayList<>();Student s1=new Student("徐凤年",29);Student s2=new Student("姜泥",26);Student s3=new Student("徐龙象",23);Student s4=new Student("李淳罡",44);list.add(s1);list.add(s2);list.add(s3);list.add(s4);//方式一运用list特有的方法进行遍历for(int i=0;i< list.size();i++){Student s= list.get(i);System.out.println(s);}System.out.println("--------------------------------------");//方式二:利用list集合特有迭代器遍历ListIterator<Student> lit= list.listIterator();while(lit.hasNext()){Student s=lit.next();System.out.println(s.getName()+"---"+s.getAge());}System.out.println("--------------------------------------");//方式三:增强for循环for(Student s:list){System.out.println(s);}}
}
//学生类
package com.qf.test3;import java.util.Objects;public class Student {private String name;private int age;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic int hashCode() {return Objects.hash(name, age);}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;return age == student.age && name.equals(student.name);}}

Vector集合子实现类  (collection和list的子实现类)

底层数据结构是数组，查询快，增删慢;线程安全，效率低

特有功能 

public void addElement(E obj) 添加元素,类似于List的add方法

public E elementAt(int index) 获取指定位置的元素 ,类似于List集合的get方法

public Enumeration elements() 遍历所有的元素,类似于List的迭代器

特有的遍历方式 

Vector特有的遍历方式

Enurmation elements()

boolean hasMoreElements()

nextElement()

普通for

size()+elementAt(int index)

 LinkedList子实现类(collection和list的子实现类)

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

LinkedList集合特有功能

public void addFirst(E e) 添加链表开头

addLast(E e) 添加链表结尾

public E getFirst() 获取链表第一个

getLast() 获取链表最后一个

public E removeFirst() 删除第一个

public E removeLast() 删除最后一个

List集合去重 

//String去重
import java.util.ArrayList;
import java.util.List;public class ListStringquchong {public static void main(String[] args) {List<String> list=new ArrayList<>();list.add("abc");list.add("gsf");list.add("gsf");list.add("abc");list.add("ccc");list.add("ccc");list.add("ab");list.add("ab");List<String> ls1=new ArrayList<>();for(int i=0;i< list.size();i++){String s=list.get(i);if(ls1.contains(s)==false){ls1.add(s);}}for(String s:ls1){System.out.println(s);}}
}
//自定义去重
import java.util.ArrayList;
import java.util.List;public class Tistzidingyiquchong {public static void main(String[] args) {List<Student> ls=new ArrayList<>();Student s1=new Student("乔峰",44);Student s2=new Student("杨过",43);Student s3=new Student("杨过",43);Student s4=new Student("乔峰",44);Student s5=new Student("乔峰",44);Student s6=new Student("灭绝师太",44);ls.add(s1);ls.add(s2);ls.add(s3);ls.add(s4);ls.add(s5);ls.add(s6);List<Student> ls1=new ArrayList<>();for(int i=0;i<ls.size();i++){Student s=ls.get(i);if(ls1.contains(s)==false){ls1.add(s);}}for(Student s:ls1){System.out.println(s);}}}

增强for 

简化数组和Collection集合的遍历

格式:
for(元素数据类型 变量 : 数组或者Collection集合) {使用变量即可，该变量就是元素
}

包,内部类,常用类,集合相关推荐

1. 浅谈Java锁,与JUC的常用类,集合安全类,常用辅助类,读写锁,阻塞队列,线程池,ForkJoin,volatile,单例模式不安全,CAS,各种锁

   浅谈JUC的常用类 JUC就是java.util.concurrent-包下的类 回顾多线程 Java默认有几个线程? 2 个 mian.GC Java 真的可以开启线程吗? 开不了,点击源码得知:本 ...

2. 第11-15章枚举|异常|常用类|集合|泛型

   文章目录 第11章 枚举和注解 11.1举例 11.2枚举的二种实现方式 11.3enum 实现接口 11.4注解的理解 11.4基本的 Annotation 介绍 第12章 异常-Exception ...

3. Day 7 2021.3.8Final-权限修饰符-部分常用类-集合-泛型

   Day 7 2020.3.8 Final关键字 package com.hong.Day007.Demo01; /* final关键字代表最终的.不可改变的 常见四种用法: 1.可以用来修饰一个类 格 ...

4. java 接口与包_java常用类包接口

   类 String Integer Long File Date Thread (java.lang.Thread Thread类的定义:public class Thread extends Obje ...

5. util包的常用类及其方法（上）

   util包为JDK内置的一个包,与lang包不同的是,使用util包的类时需要引用: import java.util.* 1.Random类 Random类用来生成随机数,构造器有: Random( ...

6. java.io包有哪些方法_java.io包下常用类及常用方法介绍

   测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试 ...

7. rpm常用命令集合2

   提要: RPM 是 Red Hat Package Manager 的缩写,原意是Red Hat 软件包管理:本文介绍RPM,并结合实例来解说RPM手工安装.查询等应用: 正文:RPM包管理的用途: ...

8. rpm常用命令集合1

   提要:RPM 是 Red Hat Package Manager 的缩写,原意是Red Hat 软件包管理:本文介绍RPM,并结合实例来解说RPM手工安装.查询等应用: 正文:RPM包管理的用途: 1 ...

9. 第四周 Java语法总结_内部类_常用类_getclass_toStrong_equals_clone_Scanner_String_StringBuffer_Integer_集合_插入排序

   文章目录 20.内部类 1.格式 2.外部类访问内部类 3.局部内部类 4.匿名内部类 1)方法的形式参数是接口 2)关于匿名内部类在开发中的使用 3)方法的返回值是接口或抽象类型 16.常用类 1. ...

最新文章

1. 发现错误（Core Data 应用程序实践指南）
2. 通过WebBrowser使用Echats
3. 时序分析：隐马尔可夫模型
4. doubango简介
5. 重大技术突破首次发布！十问解密云栖大会！
6. centos 静态拨号
7. flask程序打包部署_如何使用Flask构建Web应用程序并将其部署到云中
8. python文件例题_文件操作练习题
9. ‘grep‘ 不是内部或外部命令，也不是可运行的程序或批处理文件-adb shell ps | grep ***
10. 自食其力！ASP.NET 4打造HTML5视频控件
11. js获取chrome浏览器版本信息
12. MySQL 索引原理
13. 西部世界分析：人民网点名IPFS 分布式存储打开千亿级市场
14. MacBook Pro 入手一年了，到底香不香？
15. 2020美容师（中级）复审模拟考试及美容师（中级）模拟考试系统
16. 解决vscode进行chrome调试时报错：localhost拒绝连接请求
17. [POJ3384]Feng Shui（半平面交+凸包）
18. 【操作系统】I/O系统
19. 减少在线去重造成的数据碎片
20. python 给PDF添加目录

热门文章

1. [048量化交易]python获取股票 量比 换手率 市盈率-动态 市净率 总市值 流通市值写入数据库MongoDB
2. C语言编程题—结构体—设计程序，已知学生的记录由学号和学习成绩构成，N名学生的数据已存入a结构体数组中。请编写函数 fun：找出成绩最低的学生记录，通过形参返回主函数(规定只有一个最低分
3. 实验5 ：分析system_call中断处理过程
4. unity 3d游戏开发_使用Unity 5开发3D游戏
5. 太戈编程 1072. 优惠促销 答案及讲解
6. 如何用python画一束花_如何在AI里绘制一束春天的花朵
7. android 点阵字体生成,点阵字体 ASCII码 汉字库 自我学习 简单总结
8. HCIA随堂习题卷三
9. CoppeliaSim基础：页面、视图、可视对象（相机/视觉传感器）
10. 再见牛根生，再见英雄时代