java 基础概括05

最新推荐文章于 2023-05-31 13:25:57 发布

你可曾梦见过蝴蝶

最新推荐文章于 2023-05-31 13:25:57 发布

阅读量126

点赞数

分类专栏： java学习文章标签： java 零基础 Java 编程语言学习 Java 编程思想代码最新版初级中级高级面试题 java 找工作 Java 基础题

本文链接：https://blog.csdn.net/sinat_42368398/article/details/107145672

版权

java学习专栏收录该内容

7 篇文章 0 订阅

订阅专栏

一、常用的API
1.object类
java.lang.Object 类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。如果一个类没有特别指定父类，那么默认则继承自Object类。例如：

public class MyClass /*extends Object*/ {
 // ... 
}

public String toString() ：返回该对象的字符串表示。
toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。
覆盖重写:
如果不希望使用toString方法的默认行为，则可以对它进行覆盖重写。例如：

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

小提示:
在我们直接使用输出语句输出对象名的时候,其实通过该对象调用了其toString()方法。

public boolean equals(Object obj) ：指示其他某个对象是否与此对象“相等”。
调用成员方法equals并指定参数为另一个对象，则可以判断这两个对象是否是相同的。这里的“相同”有默认和自定义两种方式。
1.默认地址比较
如果没有覆盖重写equals方法，那么Object类中默认进行 == 运算符的对象地址比较，只要不是同一个对象，结果必然为false。
2.对象内容比较
如果希望进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同，则可以覆盖重写equals方法。例如：

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

    public Person() {
    }

    public Person(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 String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person)) return false;
        Person person = (Person) o;
        return getAge() == person.getAge() &&
                Objects.equals(getName(), person.getName());
    }

    @Override
    public int hashCode() {
        return Objects.hash(getName(), getAge());
    }

测试:

   Person person1 = new Person();
        person1.setName("1111");
        Person person2 = new Person();
        person2.setName("1111");
        System.out.println("person1的地址值为:"+person1);
        System.out.println("person2的地址值为:"+person2);
        boolean equals = person1.equals(person2);
        System.out.println(equals);
结果:
当重写了equals方法以后,输出结果为ture,
没有重写equals时,输出结果为false

结论:
== 比较的是变量(栈)内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象。比较的是真正意义上的指针操作。equals用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的，所以适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的equals方法返回的却是==的判断,如果覆盖以后那么比较的是内容是否相等。
2.Date类
java.util.Date 类表示特定的瞬间，精确到毫秒。

public Date() ：分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。

 System.out.println(new Date());
结果:
Fri Jul 03 05:01:41 CST 2020

提示:
在使用println方法时，会自动调用Date类中的toString方法。Date类对Object类中的toString方法进行了覆盖重写，所以结果为指定格式的字符串。
DateFormat类
java.text.DateFormat 是日期/时间格式化子类的抽象类，我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。

格式化：按照指定的格式，从Date对象转换为String对象。
解析：按照指定的格式，从String对象转换为Date对象。
构造方法:
由于DateFormat为抽象类，不能直接使用，所以需要常用的子类 java.text.SimpleDateFormat 。这个类需要一个模式（格式）来指定格式化或解析的标准。构造方法为：
public SimpleDateFormat(String pattern) ：用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
参数pattern是一个字符串，代表日期时间的自定义格式。

创建SimpleDateFormat对象的代码如：

 //多态
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = dateFormat.format(new Date());
        System.out.println(format);
结果:
2020-07-03 05:07:32

public String format(Date date) ：将Date对象格式化为字符串。 - public Date parse(String source) ：将字符串解析为Date对象。

//1
 try {
            DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
            String str = "2020年7月3日";
            Date date = null;
            date = df.parse(str);
            System.out.println(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
结果:
Fri Jul 03 00:00:00 CST 2020

二、Collection集合

集合：集合是java中提供的一种容器，可以用来存储多个数据。
集合和数组既然都是容器，它们有啥区别呢？

数组的长度是固定的。
集合的长度是可变的。
数组中存储的是同一类型的元素，可以存储基本数据类型值。
集合存储的都是对象。而且对象的类型可以不一致。
在开发中一般当对象多的时候，使用集合进行存储。
集合按照其存储结构可以分为两大类，分别是单列集合 java.util.Collection 和双列集合 java.util.Map ，我们从 Collection 集合开始
Collection：单列集合类的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口，分别是 java.util.List 和 java.util.Set 。
List 的特点是元素有序、元素可重复。
Set 的特点是元素无序，而且不可重复。
List 接口的主要实现类有 java.util.ArrayList 和 java.util.LinkedList 。
Set 接口的主要实现类有 java.util.HashSet 和 java.util.TreeSet 。
#####Collection 常用功能
Collection是所有单列集合的父接口，因此在Collection中定义了单列集合(List和Set)通用的一些方法，这些方法可用于操作所有的单列集合。方法如下：

- public boolean add(E e) ： 把给定的对象添加到当前集合中 。
- public void clear() :清空集合中所有的元素。
- public boolean remove(E e) : 把给定的对象在当前集合中删除。
- public boolean contains(E e) : 判断当前集合中是否包含给定的对象。
- public boolean isEmpty() : 判断当前集合是否为空。
- public int size() : 返回集合中元素的个数。
- public Object[] toArray() : 把集合中的元素，存储到数组中。

示例:

public class Demo1Collection {
 public static void main(String[] args) {
  // 创建集合对象 
// 使用多态形式
 Collection<String> coll = new ArrayList<String>();
 // 使用方法
 // 添加功能boolean add(String s) 
coll.add("小李广");
coll.add("扫地僧");
 coll.add("石破天");
 System.out.println(coll);
 // boolean contains(E e) 判断o是否在集合中存在
 System.out.println("判断 扫地僧 是否在集合中"+coll.contains("扫地僧"));
 //boolean remove(E e) 删除在集合中的o元素
 System.out.println("删除石破天："+coll.remove("石破天"));
 System.out.println("操作之后集合中元素:"+coll); 
// size() 集合中有几个元素
 System.out.println("集合中有"+coll.size()+"个元素");
 // Object[] toArray()转换成一个Object数组
 Object[] objects = coll.toArray();
 // 遍历数组
 for (int i = 0; i < objects.length; i++) { 
System.out.println(objects[i]);
 }
// void clear() 清空集合 
coll.clear();
 System.out.println("集合中内容为："+coll);
 // boolean isEmpty() 判断是否为空 System.out.println(coll.isEmpty());
 }
}

泛型
在前面学习集合时，我们都知道集合中是可以存放任意对象的，，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。
提示:一般在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型。
#####泛型的定义与使用
泛型，用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。
定义和使用含有泛型的类
定义格式：

修饰符 class 类名<代表泛型的变量> { }

示例:

class ArrayList<E>{
 public boolean add(E e){ 
}
 public E get(int index){
 } 
....
}

使用泛型：即什么时候确定泛型。
在创建对象的时候确定泛型
例如:

ArrayList<String> list = new ArrayList<String>();

此时，变量E的值就是String类型,那么我们的类型就可以理解为：

class ArrayList<String>{
 public boolean add(String e){ 
  } 
public String get(int index){
 }
 ...
 }

再例如:

ArrayList<Integer> list = new ArrayList<Integer>();

此时，变量E的值就是Integer类型,那么我们的类型就可以理解为：

class ArrayList<Integer> {
 public boolean add(Integer e) {
 }
 public Integer get(int index) {
 }
 ...
 }

举例自定义泛型类

public class MyGenericClass<MVP> {
 //没有MVP类型，在这里代表 未知的一种数据类型 未来传递什么就是什么类型
 private MVP mvp;
 public void setMVP(MVP mvp) { 
    this.mvp = mvp;
 }
 public MVP getMVP() {
     return mvp;
 }
 }

使用:

public class GenericClassDemo {
 public static void main(String[] args) {
 // 创建一个泛型为String的类
 MyGenericClass<String> my = new MyGenericClass<String>(); // 调用setMVP
 my.setMVP("大胡子登登");
 // 调用getMVP
 String mvp = my.getMVP();
 System.out.println(mvp); 
//创建一个泛型为Integer的类
 MyGenericClass<Integer> my2 = new MyGenericClass<Integer>();
 my2.setMVP(123);
 Integer mvp2 = my2.getMVP();
 }
 }

含有泛型的方法
定义格式：

修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ }

例如

public class MyGenericMethod {
 public <MVP> void show(MVP mvp) {
 System.out.println(mvp.getClass());
 }
public <MVP> MVP show2(MVP mvp) {
 return mvp;
 } 
}

使用格式：调用方法时，确定泛型的类型

public class GenericMethodDemo {
 public static void main(String[] args) {
 // 创建对象
 MyGenericMethod mm = new MyGenericMethod();
 // 演示看方法提示
 mm.show("aaa");
 mm.show(123);
 mm.show(12.45);
 }
 }

含有泛型的接口
定义格式：

修饰符 interface接口名<代表泛型的变量> { }

例如

public interface MyGenericInterface<E>{
 public abstract void add(E e);
 public abstract E getE();
 }

使用格式：
1.定义类时确定泛型的类型

public class MyImp1 implements MyGenericInterface<String> {
 @Override
 public void add(String e) {
 // 省略... 
}
@Override
 public String getE() {
 return null;
 } 
}

此时，泛型E的值就是String类型。
2.始终不确定泛型的类型，直到创建对象时，确定泛型的类型
例如:

public class MyImp2<E> implements MyGenericInterface<E> {
 @Override
 public void add(E e) {
 // 省略...
 }
@Override
 public E getE() {
 return null; 
} 
}

确定泛型：

/** 使用 */ 
public class GenericInterface {
 public static void main(String[] args) {
 MyImp2<String> my = new MyImp2<String>();
 my.add("aa"); 
  }
}

List集合

List接口特点：

它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、 22、33的顺序完成的）。
它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。 tips:我们在基础班的时候已经学习过List接口的子类java.util.ArrayList类，该类中的方法都是来自List中定义。

public void add(int index, E element) : 将指定的元素，添加到该集合中的指定位置上。
public E get(int index) :返回集合中指定位置的元素。
public E remove(int index) : 移除列表中指定位置的元素, 返回的是被移除的元素。
public E set(int index, E element) :用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
#####ArrayList集合:
java.util.ArrayList 集合数据存储的结构是数组结构。
元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以 ArrayList 是最常用的集合。许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。
#####LinkedList集合
java.util.LinkedList 集合数据存储的结构是链表结构。方便元素添加、删除的集合。
public void addFirst(E e) :将指定元素插入此列表的开头。
public void addLast(E e) :将指定元素添加到此列表的结尾。
public E getFirst() :返回此列表的第一个元素。
public E getLast() :返回此列表的最后一个元素。
public E removeFirst() :移除并返回此列表的第一个元素。
public E removeLast() :移除并返回此列表的最后一个元素。
public E pop() :从此列表所表示的堆栈处弹出一个元素。
public void push(E e) :将元素推入此列表所表示的堆栈。
public boolean isEmpty() ：如果列表不包含元素，则返回true。

public class LinkedListDemo {
 public static void main(String[] args) {
 LinkedList<String> link = new LinkedList<String>(); 
//添加元素
 link.addFirst("abc1");
 link.addFirst("abc2");
 link.addFirst("abc3"); 
System.out.println(link);
 // 获取元素
 System.out.println(link.getFirst()); 
System.out.println(link.getLast());
 // 删除元素
 System.out.println(link.removeFirst()); 
System.out.println(link.removeLast());
 while (!link.isEmpty()) {
 //判断集合是否为空
 System.out.println(link.pop());
 //弹出集合中的栈顶元素
 }
System.out.println(link);
  }
}

三、 Map集合
现实生活中，我们常会看到这样的一种集合：IP地址与主机名，身份证号与个人，系统用户名与系统用户对象等，这种一一对应的关系，就叫做映射。Java提供了专门的集合类用来存放这种对象关系的对象，即 java.util.Map 接口。我们通过查看 Map 接口描述，发现 Map 接口下的集合与 Collection 接口下的集合，它们存储数据的形式不同，如下图。

Collection 中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。
Map 中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。
Collection 中的集合称为单列集合，
Map 中的集合称为双列集合。
需要注意的是， Map 中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。
Map常用子类
通过查看Map接口描述，看到Map有多个子类，这里我们主要讲解常用的HashMap集合、LinkedHashMap集合。
HashMap：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
LinkedHashMap：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的 hashCode()方法、equals()方法。
方法：
public V put(K key, V value) : 把指定的键与指定的值添加到Map集合中。
public V remove(Object key) : 把指定的键所对应的键值对元素在Map集合中删除，返回被删除元素的值。
public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
public Set keySet() : 获取Map集合中所有的键，存储到Set集合中。
public Set<Map.Entry<K,V>> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)。

public class MapDemo {
 public static void main(String[] args) {
 //创建 map对象
 HashMap<String, String> map = new HashMap<String, String>();
 //添加元素到集合
 map.put("黄晓明", "杨颖");
 map.put("文章", "马伊琍");
 map.put("邓超", "孙俪");
 System.out.println(map);
 //String remove(String key)
 System.out.println(map.remove("邓超"));
 System.out.println(map);
 // 想要查看 黄晓明的媳妇 是谁
 System.out.println(map.get("黄晓明"));
 System.out.println(map.get("邓超"));
 }
 }

提示:

使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中；
若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值。
#####Map集合遍历键找值方式
键找值方式：即通过元素中的键，获取键所对应的值

获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法提示: keyset()
遍历键的Set集合，得到每一个键。
根据键，获取键所对应的值。方法提示: get(K key)

public class MapDemo01 {
 public static void main(String[] args) {
 //创建Map集合对象
 HashMap<String, String> map = new HashMap<String,String>(); 
//添加元素到集合
 map.put("胡歌", "霍建华");
 map.put("郭德纲", "于谦");
 map.put("薛之谦", "大张伟");
 //获取所有的键 获取键集
Set<String> keys = map.keySet(); 
// 遍历键集 得到 每一个键
 for (String key : keys) {
 //key 就是键 //获取对应值
 String value = map.get(key); 
System.out.println(key+"的CP是："+value); 
  } 
 } 
}

Entry键值对对象

我们已经知道， Map 中存放的是两种对象，一种称为key(键)，一种称为value(值)，它们在在 Map 中是一一对应关系，这一对对象又称做 Map 中的一个 Entry(项) 。 Entry 将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历 Map 集合时，就可以从每一个键值对（ Entry ）对象中获取对应的键与对应的值。
既然Entry表示了一对键和值，那么也同样提供了获取对应键和对应值得方法：

public K getKey() ：获取Entry对象中的键。
public V getValue() ：获取Entry对象中的值。
在Map集合中也提供了获取所有Entry对象的方法：
public Set<Map.Entry<K,V>> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)。

public class MapDemo02 {
 public static void main(String[] args) { 
// 创建Map集合对象
 HashMap<String, String> map = new HashMap<String,String>(); 
// 添加元素到集合
 map.put("胡歌", "霍建华"); 
map.put("郭德纲", "于谦"); 
map.put("薛之谦", "大张伟");
 // 获取 所有的 entry对象
 entrySet Set<Entry<String,String>> entrySet = map.entrySet();
 // 遍历得到每一个entry对象 
for (Entry<String, String> entry : entrySet) {
 // 解析
 String key = entry.getKey();
 String value = entry.getValue();
 System.out.println(key+"的CP是:"+value); 
  } 
  }
}

HashMap存储自定义类型键值
练习：每位学生（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到 map集合中。学生作为键, 家庭住址作为值。

public class Student {
private String name;
 private int age; public Student() {
 }
public Student(String name, int age) {
 this.name = name; 
this.age = age;
 }
public String getName() { 
return name; 
}
public void setName(String name) {
 this.name = name;
 }
public int getAge() { 
return age;
 }
public void setAge(int age) {
 this.age = age;
 }
@Override 
public boolean equals(Object o) { 
if (this == o) return true;
 if (o == null || getClass() != o.getClass())
 return false;
 Student student = (Student) o;
 return age == student.age && Objects.equals(name, student.name); 
}
@Override
 public int hashCode() {
 return Objects.hash(name, age);
 }
 }

编写测试类：

public class HashMapTest {
public static void main(String[] args) {
//1,创建Hashmap集合对象。
Map<Student,String>map = new HashMap<Student,String>();
//2,添加元素。
map.put(newStudent("lisi",28), "上海"); 
map.put(newStudent("wangwu",22), "北京"); 
map.put(newStudent("zhaoliu",24), "成都");
map.put(newStudent("zhouqi",25), "广州"); map.put(newStudent("wangwu",22), "南京");
//3,取出元素。键找值方式
Set<Student>keySet = map.keySet();
for(Student key: keySet){
Stringvalue = map.get(key); 
System.out.println(key.toString()+"....."+value);
}
}
}

当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的 hashCode和equals方法。如果要保证map中存放的key和取出的顺序一致，可以使用 java.util.LinkedHashMap 集合来存放。
LinkedHashMap
我们知道HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，那么我们要保证有序，还要速度快怎么办呢？在HashMap下面有一个子类LinkedHashMap，它是链表和哈希表组合的一个数据存储结构。

public class LinkedHashMapDemo { 
public static void main(String[] args) {
 LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();
 map.put("邓超", "孙俪");
 map.put("李晨", "范冰冰");
 map.put("刘德华", "朱丽倩"); 
Set<Entry<String, String>> entrySet = map.entrySet(); 
for (Entry<String, String> entry : entrySet) { 
System.out.println(entry.getKey() + " " + entry.getValue());
 }
 }
 }

你可曾梦见过蝴蝶

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java 基础概括05

一、常用的API1.object类java.lang.Object 类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。如果一个类没有特别指定父类，那么默认则继承自Object类。例如：public class MyClass /*extends Object*/ { // ... }public String toString() ：返回该对象的字符串表示。toString方法返回该对象的字符串表示，其实该字
复制链接

扫一扫