java学习笔记（二）

最新推荐文章于 2024-03-19 18:08:05 发布
最新推荐文章于 2024-03-19 18:08:05 发布
阅读量1k 收藏
点赞数
文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43149074/article/details/124000009
版权

1.容器collection

collection接口：定义了一组对象的方法，子接口set list定义存储方式

​ set：数据对象无顺序，不可重复

​ list：有顺序，可重复

map接口：定义存储 键（key）-值（value）映射对 方法

ArrayList

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yWNbPeE5-1649250243897)(C:\Users\17427\AppData\Roaming\Typora\typora-user-images\1648792177931.png)]

public class Test01 {
	public static void main(String[] args) {
		List list = new ArrayList();
		//ArrayList:底层实现时数组,线程不安全，效率高。所以，查询快。修改、插入、删除慢。
		//LinkedList:底层实现是链表,线程不安全，效率高。所以，查询慢。修改、插入、删除快。
		//Vector:线程安全的，效率低。
		
		list.add("aaa");
		list.add("aaa");
		list.add(new Date());
		list.add(new Dog());
		list.add(1234);  //包装类的：自动装箱！
		list.remove(new String("aaa"));
		System.out.println(list.size());
		for(int i=0;i<list.size();i++){
			System.out.println(list.get(i)); 
		}
		
		list.set(3, new String("3333"));
		list.add(4, new String("3333"));
		System.out.println(list.isEmpty());
		list.remove(new Dog());      //hashcode和equals
		System.out.println(list.size());
		
		List list2 = new ArrayList();
		list2.add("bbb");
		list2.add("ccc");
		
		list.add(list2);
		
		//跟顺序的操作
		String str = (String) list.get(0);
		System.out.println(str); 
		list.add(1,"bb")// 添加
		list.set(1, "ababa");// 覆盖修改
		list.remove(0);
		list.get(1);
		int a=list.indexOf("bb");
		
 	}

}

class Dog {
	
}

自定义MyArrayList

package collection;

public class MyArrayList {
	private Object[] elementData;
	private int size;
	public int size() {
		return size;
	}
	public boolean isEmpty() {
		return size==0;
	}
	public MyArrayList() {
		this(10);//构造
	}
	public MyArrayList(int initialCapacity) {
		if(initialCapacity<0) {
			try {
				throw new Exception();
			}catch (Exception e) {
				e.printStackTrace();
			}
		}
		elementData = new Object[initialCapacity];//默认初始10
	}
	public void add(Object obj) {
		//数组扩容和拷贝		
		if(size>elementData.length) {
			Object[] newArray = new Object[size*2+1];
			System.arraycopy(elementData, 0, newArray, 0, elementData.length);
			elementData = newArray;
		}
		elementData[size]=obj;
		size++;
	}
	public Object get(int index){
		rangeCheck(index);//范围检测
		
		return elementData[index];
	}
	private void rangeCheck(int index){//private方法 ，内部使用
		if(index<0||index>=size){
			try {
				throw new Exception();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}}
	public static void main(String[] args) {
		MyArrayList list = new MyArrayList(3);
		System.out.println(list.size());
		list.add("333");
		System.out.println(list.size() ); 
		System.out.println(list.get(0));
}
}

自己实现LinkedList 基于链表

定义Node，实现getset方法和构造方法

public class Node {
	Node previous;//上一个节点
	Object obj;
	Node next; // 下一个节点

自定义MyLinkedList

public class MyLinkedList {
	private Node first;
	private Node last;
	private int size;
	
	public int size(){
		return size;
	}
	private void rangeCheck(int index){
		if(index<0||index>=size){
			try {
				throw new Exception();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
	//add方法
	public void add(Object obj) {
		Node n=new Node();
		if(first==null) {
			n.setPrevious(null);
			n.setObj(obj);
			n.setNext(null);
			first=n;
			last=n;
		}else {
			//直接在last节点后增加节点
			n.setPrevious(last);
			n.setObj(obj);
			n.setNext(null);
			last.setNext(n);
			last=n;
		}
		size++;
	}
	public Object get(int index){   //2
		rangeCheck(index);
		
		// 0 1 2 3 4
		Node temp = node(index);
		if(temp!=null){
			return temp.obj;
		}
		return null;
	}
	public Node node(int index){
		Node temp = null;
		if(first!=null){
			if (index < (size >> 1)) {
				temp = first;
				for(int i=0;i<index;i++){
					temp = temp.next;
				}
			}else{
				temp = last;
	            for (int i = size - 1; i > index; i--){
	            	temp = temp.previous;
	            }
			}
			
		}
//		LinkedList l;
		return temp;
	}
	public static void main(String[] args) {
		MyLinkedList list = new MyLinkedList();
		list.add("aaa");
		list.add("bbb");
		System.out.println(list.get(1)); 
	}
}

实现Map

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LygkqNWb-1649250243901)(C:\Users\17427\AppData\Roaming\Typora\typora-user-images\1648792220995.png)]

Map(key,value);底层是数组加链表

public class MyMap01 {
	
	MyEntry[] arr = new MyEntry[99];
	int size;
	public void put(Object key,Object value) {
		MyEntry e=new MyEntry(key,value);
			arr[size++]=e;
		}
	public Object get(Object key) {
		for(int i=0;i<size;i++) {
			if(arr[i].key.equals(key)) {
				return arr[i].value;
			}
		}
		return null;
	}
	
	public static void main(String[] args) {
		MyMap01 m=new MyMap01();
		m.put("yi", "ni");
		m.put("er", "hao");
		String w=(String)m.get("yi");
		System.out.println(w.hashCode());
	}
}

class MyEntry{
	Object key;
	Object value;
	public MyEntry(Object key, Object value) {
		super();
		this.key = key;
		this.value = value;
	}
	
}

完善版map

package collection;

import java.util.LinkedList;

public class Map002 {
	LinkedList[] arr=new LinkedList[999];
	int size;
	
	public void put(Object key,Object value) {//Map底层结构是数组加链表
		MyEntry e=new MyEntry(key,value);
		int a=key.hashCode()%999;//key值的hashcode取余数
		if(arr[a]==null) {
			LinkedList list = new LinkedList();
			arr[a]=list;
			list.add(e);
		}else {
			LinkedList list =arr[a];
			for(int i=0;i<list.size();i++) {
				MyEntry e2=(MyEntry)list.get(i);
				if(e2.key.equals(key)) {
					e2.value=value;//键相同 值覆盖
				}
			}
		}
	}
	public Object get(Object key) {
		int a = key.hashCode()%999;
		if(arr[a]!=null) {
			LinkedList list=arr[a];
			for(int i=0;i<list.size();i++) {
				MyEntry e=(MyEntry)list.get(i);
				if(e.key.equals(key)) {
					return e.value;
				}
			}
		}
		return null;
	}
	
	public static void main(String[] args) {
		Map002 map=new Map002();
		map.put(1, "hello");
		map.put(1, "u");
		System.out.println(map.get(1));
	}
	
}
class MyEntry{
	Object key;
	Object value;
	public MyEntry(Object key, Object value) {
		super();
		this.key = key;
		this.value = value;
	}
	
}

Equals和hashcode

两个内容相同的对象具有相等的hashcode；

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Waed2WB1-1649250243903)(C:\Users\17427\AppData\Roaming\Typora\typora-user-images\1645606894280.png)]

set-无序不可重复

hashset：以map实现，存入对象作map的key值，所以不能重复。

public class MySet {
	
	HashMap map;
	private static final Object PRESENT = new Object();//常量value
	public MySet() {
		map=new HashMap();
	}
	public int size() {
		return map.size();
	}
	public void add(Object o) {
		map.put(o, PRESENT);//传入到key,key值不可重复
	}

	public static void main(String[] args) {
		MySet s=new MySet();
		s.add("aa");
		System.out.println(s.size());
	}
}
数据存储

实体类：


package collection;

public class Student {//JavaBean 实体类
	private int id;
	private String name;
	private String classNo;
	
	public Student(int id, String name, String classNo) {
		super();
		this.id = id;
		this.name = name;
		this.classNo = classNo;
	}
	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 getClassNo() {
		return classNo;
	}
	public void setClassNo(String classNo) {
		this.classNo = classNo;
	}
	

}

存入数据

package collection;

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

public class TestStu {
	public static void main(String[] args) {
		Student s1=new Student(1,"son","one");
		Student s2=new Student(2,"sun","two");
		
		List<Student> list = new ArrayList<Student>();
		list.add(s1);
		list.add(s2);
		
		System.out.println(list.get(1).getName());
	}
}

或者使用map封装数据

package collection;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class TestStu {
	public static void main(String[] args) {
		Map map = new HashMap();  //一行数据用一个map封装
		map.put("id",1);
		map.put("name","son");
		map.put("classNo","one");
		
		Map map2 = new HashMap();
		map2.put("id",2);
		map2.put("name","sun");
		map2.put("classNo","two");
		
		List<Map> list = new ArrayList<Map>();
		list.add(map);
		list.add(map2);
		System.out.println(list.get(1).get("name"));
	}
}

iterator迭代器

**接口定义：**collection接口定义

Boolean hasNext();//判断是否有元素没有被遍历

Object next();//返回游标当前位置元素，并将有游标移动到下一个位置

void remove();//删除游标左边元素

public class Test01 {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("aa");
		list.add("bb");
		list.add("cc");
		System.out.println(list);
		for(int i=0;i<list.size();i++) {
			System.out.println(list.get(i));
		}
		
		Set set = new HashSet();
		set.add("1");
		set.add("2");
		set.add("3");
		
		Iterator iter = set.iterator();
		while(iter.hasNext()) {//for(Iterator iter=set.iterator;iter.hasNext();)
			String str=(String)iter.next();
			System.out.println(str);
			
			//map中使用迭代器
			Map map = new HashMap();
			Iterator iter = map.entrySet().iterator();
			while(iter.hasNext()){
                Map.Entry entry = (Map.Entry) iter.next();
                Object key = entry.getKey();
                Object val = entry.getValue();
			}
			//第二种 效率低
			Map map = new HashMap();
			Iterator iter = map.keySet().iterator();
			while(iter.hasNext()){
                Object key = iter.next();
                Object val = map.get(key);
			}
		}
	}

泛型

-参数化类型，使用广泛的类型

作用：

​ 安全：编译时检查类型安全

​ 省心：所有强制转换都是自动、隐式的，提高代码重用率。

类泛型：定义类时使用泛型

格式：class 类名<字母>{

​ 修饰符 字母 属性；

​ 修饰符 构造器（字母）

​ 修饰符 返回类型 方法（字母）

}

泛型常见字母：T KV E ？

泛型声明时不能使用，不能使用在静态属性和方法上

使用时确定类型，不能使用基本类型

public class Studenet<t1,t2>{
    t1 java;
    t2 score;
}
//使用时指定类型
Student<String,Integer> s=new Student<String,Integer>(){
    
}

接口中使用泛型，只能使用在方法中，不能使用在全局常量中

public interface Com<T>{
    void com(T t);
}

泛型方法<> 返回类型 只能访问对象信息，不能修改信息

public static void main(String[] args){
    test("a");//T-->String 
}
//泛型方法
public static <T> void test(T a){
    System.out.println(a);
}

父类泛型类 子类指定具体类型

//父类泛型类 属性和方法
public abstract class Father<T>{
    T name;
    public abstract void test(T t);
}
//子类声明时指定具体类 属性、方法为具体类型
class Child extends Father<String>{
    String t2;
    @Override
    public void test(String t){
        
    }
}
//子类为泛型类
class Child2<T> extends Father<T>{
    pubnlic void test(T t){
        
    }
}
//子类泛型类，父类不指定类型，泛型的擦除,使用Object替换
class Child3<T> extends Father{
    public void test(Object t){
        
    }
}
//子类父类同时擦除
class Child4 extends Father{
String name;
    public void test(Object t){
        
    }
}

泛型接口：与继承同理 重写方法随父类而定

public interface Com<T>{
    
}
//生明子类  指定具体类型
class Co implements Com<Integer>{
    
}
//擦除
class Co1 implements Com{
    
}
//父类擦除 子类泛型
class Com2<T> implements Com{
    
}
//子类泛型》=父类泛型
class Com3<T> implements Com<T>{
    
}//父类泛型 子类擦除错误

**泛型无多态，通配符？ extends super **

？可以在声明类型和方法参数上使用，不能声明类

？可以接受泛型任意类型，只能接受和输出，不能修改

public class Student<T>{
    T score;
    
    public static void test(Student<?> stu){
        
    }
    public static void main(String[] args){
        Student<?> stu = new Student<String>();
        test(new Student<Integer>());//使用声明类型
        test2(new Student<Apple>());//多态的功能
    }
    //泛型使用多态 ？extends上限 子类或自身nds并表示 <=
    //？ super 下限
    public static void test2(Student<? extends Fruit> stu){
        
    }
}

泛型的嵌套 使用时层层拆分

public class Test<T>{
    T stu;
    
    public static void main(String[] args){
        Test<Student<String>> room = new Test<Student<String>>();
        //从外道内拆分
        room.stu=new Student<String>();
        Student<String> stu = room.stu;
        String score = stu.score;
        System.out.prinln(score);
    }
}

hashmap分拣思路

package collection.map;

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

public class Demo01 {
	public static void main(String[] args) {
		String str="this is a cat and that is a mice"
				+ " and where is the food";
		//分割字符串
		String[] strArray=str.split(" ");
		//存储到Map中 分拣思路
		Map<String,Letter> letter = new HashMap<String,Letter>();
		for(String temp:strArray) {
			//1.为所有key创建容器
			if(!letter.containsKey(temp)) {
				letter.put(temp,new Letter());
			}
			//2容器中直接存放对应value
			Letter col=letter.get(temp);
最低0.47元/天 解锁文章
wangll8243
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java学习笔记总结
04-02
自己几个月的学习总结，一些解决问题的办法，很实用，希望对大家有所帮助！
java学习笔记.zip
11-16
java学习笔记java学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记...
java学习笔记（持续更新）
快乐学习，daydayup!
12-24 7095
如果您也在学习java，希望能够和您一起讨论，一起学习。这篇文章是记录笔者0基础学习java的过程，如果您阅读这篇文章时，发现一些错误，也希望您愿意指出。本次java学习流程以黑马程序员的java教学视频为主，其他博主或公开教程为辅。学习过程中遇到的一些个别情况或错误都会记录其中并记载解决方案。本篇学习记录会一直更新，希望能与大家一起学习，共同成长。
JAVA学习笔记：目录
任性的生鱼片 的博客
12-28 1931
目录 java学习笔记1：了解java、JDK、JRE、JVM java学习笔记2：JDK下载和安装以及测试控制台测试是否配置成功 java学习笔记3：用记事本写第一个java程序，第一个java程序常见错误总结，第一个java程序详细解析 java学习笔记4：常见的DOS命令和java开发工具 java学习笔记5：eclipse的下载及使用，以及java程序的运行 java学习笔记6：注释、标识...
Java 学习笔记：面向对象
最新发布
Li__Daxia的博客
03-19 988
Java 学习笔记：面向对象
Thinking in Java读书笔记
热门推荐
yjclsx的博客
07-31 42万+
Thinking in Java读书笔记（IO和并发除外） 1.1、类中所有的private方法都隐式地指定为final的，由于其他类无法取用private方法，所以也就无法覆盖它；private方法无法被重写，继承对应private的方法无效，private的属性也无法拿到，但我们通常private的属性有对应的get、set方法，通常是public的，所以子类继承后可以调用方法来取得到父类的...
JAVA学习笔记（韩顺平老师）
2301_77385325的博客
04-19 1669
说明：本文为韩顺平老师的JAVA课程学习笔记，仅供自身学习参考，如有纰漏，请多指教，如有帮助，不胜荣幸。
JAVA基础学习大全（笔记）
Frank---7的博客
12-22 9万+
JAVASE和JAVAEE的区别 JDK的安装路径 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-perPRPgq-1608641067105)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222001641906.png)] 卸载和安装JDK [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SYnXvbAn-1608641067107)(C:\Users
Java学习路线总结，搬砖工逆袭Java架构师
学Java，找哪吒
09-07 24万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
Java学习笔记一
u013033706的博客
10-23 1446
Java学习笔记一1、Java语言的特点2、Java程序开发过程3、Java虚拟机JVM 学习方式： 书籍：《Java基础教程》 吴仁群 清华大学出版社 1、Java语言的特点 一种面向对象且与平台无关的多线程动态语言 2、Java程序开发过程 文件名.java产生applicationapplets源文件编辑器Java编译器字节码文件由Java解释器执行由Web浏览器执行 图1 Java程...
java学习笔记
Wudu_Eleven的博客
12-11 2万+
java是一门很好的语言，也是一门庞杂的系统，学习过程中要善于记录和积累。  学习了四年java，但回头看看好像什么都没学到，是因为学习没有成系统，知识没有成系统。 面向对象编程有很多重要的特性， 比如：封装，继承，多态和抽象。下面的章节我们会逐个分析这些特性。 封装 封装给对象提供了隐藏内部特性和行为的能力。对象提供一些能被其他对象访问的方法来改变它内部的数
Java学习笔记目录索引 (持续更新中)
Guizy
01-15 12万+
Java学习路线目录索引 一、Java基础(省略) Lambda表达式及函数式接口 二、Java数据库 MySQL 一 概念、DDL、DML、DQL、事务、约束等 数据库设计 一 多表关系、三大范式 JDBC 一 基本使用、DAO组件、连接池、JDBCTemplate 三、JavaWeb HTML相关学习 CSS — 常用属性 CSS — 选择器及三大特性 CSS — 网页的布局方式 C...........................
Java基础 学习笔记 Markdownr版
06-27
Java基础 java学习笔记 Java Java基础Markdown学习笔记，可转换成PDF、Word等格式
java学习笔记资源合集
05-25
java学习笔记 Java 自 1995 年诞生，至今有 16 年的历史，从诞生之日起，逐渐被广泛接受并成为推 动了 web 迅速发展。Java 的三种核心机制为虚拟机机制、代码安全机制、垃圾回收机制。 Java 最大的特点是平台无关性...
Java学习笔记学习笔记
10-24
Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习...
java学习笔记markdown
03-12
狂神说java学习笔记，markdown版
java学习笔记java学习笔记java学习笔记java学习笔记
07-31
java学习笔记
Java学习笔记
11-21
Java学习笔记 1、连接数据库步骤 2、不同数据库的驱动程序和连接字符串 3、连接数据库常见问题 4、B/S结构和C/S结构的区别 5、如何处理中文乱码问题 6、使用JavaMail发送注册验证邮件 7、不安全的用户名密码验证 8、...
java 学习笔记 xmind
01-02
Java 学习笔记 XMind 是一款专门用于整理和管理 Java 学习内容的思维导图软件。通过 XMind，我们可以将 Java 相关的知识点、重点、代码案例、类库等内容进行整理和分类，方便我们进行学习和复习。 首先，我用 XMind...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值