Java学习笔记

最新推荐文章于 2023-07-04 21:34:45 发布
最新推荐文章于 2023-07-04 21:34:45 发布
阅读量261 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zcyt085/article/details/107738831
版权

Java编程练习——ArrayList

练习java编程，自己简单实现ArraryList，代码如下：

/**
 *MyArrayList class
 * @author zc
 *
 */
public class MyArrayList<T> {

    /**
     * DEFAULT_CAPACITY 默认长度
     */
    private static final int DEFAULT_CAPACITY = 10;
    /**
     * theSize 大小/元素个数
     */
    private int theSize;
    /**
     * theItems 数组
     */
    private T[] theItems;

    /**
     * 清空 初始化
     */
    public void clear(){
        theSize = 0;
        theItems = (T[]) new Object[DEFAULT_CAPACITY];
    }

    /**
     * 构造函数
     */
    public MyArrayList(){
        clear();
    }

    /**
     * 计算大小
     * @return 大小/元素个数
     */
    public int size(){
        return theSize;
    }

    /**
     *判断是否为空
     * @return 空为真/非空为假
     */
    public boolean isEmpty(){
        return size()==0;
    }

    /**
     * 容量扩充
     * @param minCapacity 所需最小空间
     */
    public void ensureCapacity(int minCapacity){
        if(minCapacity <= theItems.length) {
            return;
        }
        T[] old = theItems;
        int newCapacity = (theItems.length * 3)/2 + 1;
        if(newCapacity < minCapacity) {
            newCapacity = minCapacity;
        }
        theItems = (T[]) new Object[newCapacity];
        for(int i = 0; i < size(); i++ )
        {
            theItems[i] = old[i];
        }
    }

    /**
     * 根据元素下标获取元素值
     * @param index 元素下标
     * @return 元素值
     */
    public T get(int index){
        if(index >= size() || index < 0) {
            throw new ArrayIndexOutOfBoundsException();
        }
        return theItems[index];
    }

    /**
     * 修改固定位置的元素值
     * @param index 下标
     * @param newVal 新值
     * @return 被修改的元素值
     */
    public T set(int index, T newVal){
        if(index >= size() || index < 0) {
            throw new ArrayIndexOutOfBoundsException();
        }
        T old = theItems[index];
        theItems[index] = newVal;
        return old;
    }

    /**
     * 在下标处添加元素
     * @param index 下标
     * @param element 元素值
     */
    public void add(int index, T element){
        if(index >= size() || index < 0) {
            throw new ArrayIndexOutOfBoundsException();
        }
        ensureCapacity(size()+1);
        for(int i = theSize; i > index;i--)
        {
            theItems[i] = theItems[i-1];
        }
        theItems[index] = element;
        theSize++;
    }

    /**
     * 末尾添加元素
     * @param element 元素值
     * @return 添加位置
     */
    public int add(T element){
        ensureCapacity(size()+1);
        theItems[theSize++] = element;
        return size()-1;
    }

    /**
     * 获取元素值第一次出现的位置
     * @param element 元素值
     * @return 下标
     */
    public int indexOf(T element) {
        int index = -1;
        for(int i = 0; i < size(); i++)
        {
            if(element.equals(theItems[i]))
            {
                index = i;
                break;
            }
        }
        return index;
    }

    /**
     * 获取元素最后一次出现位置
     * @param element 元素值
     * @return 下标
     */
    public int lastIndexOf(T element){
        int index = -1;
        for(int i = size()-1; i >= 0; i--)
        {
            if(element.equals(theItems[i]))
            {
                index = i;
                break;
            }
        }
        return index;
    }

    /**
     * 删除下标位置元素
     * @param index 下标值
     * @return 被删除元素值
     */
    public T remove(int index){
        if(index >= size() || index < 0) {
            throw new ArrayIndexOutOfBoundsException();
        }
        T removeItem = theItems[index];
        for(int i = index; i < size()-1; i++)
        {
            theItems[i]=theItems[i+1];
        }
        theItems[theSize] = null;
        theSize--;
        return removeItem;
    }

    /**
     * 测试
     * @param args 固定参数
     */
    public static void main(String[] args) {
        MyArrayList<String > list = new MyArrayList<String>();
        System.out.println(list.isEmpty());
        list.add("123");
        list.add("234");
        list.add("345");
        list.add(1, "qwe");
        list.add("123");
        list.add("123");
        list.add("123");
        list.add("123");
        list.add("123");
        list.add("123");
        list.add("123");
        list.add("123");
        list.add("123");
        list.add("123");
        list.set(5, "wer");
        list.remove(0);

        System.out.println(list.isEmpty());
        System.out.println(list.indexOf("123") + "  " + list.lastIndexOf("123"));
        System.out.println(list.size());
        String tmp =list.get(list.size() - 1);
        System.out.println(tmp);
    }

}

属性

  • private T[] theItems: 实现MyArrayList的底层数组。
  • private static final int DEFAULT_CAPACITY: 数组的默认长度。
  • private int theSize: 数组内元素个数。

方法

  • size()
public int size(){
        return theSize;
    }

有专门标识元素个数的属性theSize，所以获取大小的方法实现简单，直接返回theSize的值即可。。

  • isEmpty()
 public boolean isEmpty(){
        return size()==0;
    }

判断是否为空也依赖于theSize属性，当数组内没有元素时即为空，否则不为空。

  • ensureCapacity()
public void ensureCapacity(int minCapacity){
        if(minCapacity <= theItems.length) {
            return;
        }
        T[] old = theItems;
        int newCapacity = (theItems.length * 3)/2 + 1;
        if(newCapacity < minCapacity) {
            newCapacity = minCapacity;
        }
        theItems = (T[]) new Object[newCapacity];
        for(int i = 0; i < size(); i++ )
        {
            theItems[i] = old[i];
        }
    }

元素的添加会是数组内的元素个数增加，当超出数组的长度时，需要进行容量的扩充来确保数组不会越界。容量扩充的具体实现步骤为：判断所需的最小容量(原元素个数+要添加的元素个数)是否满足，即所需长度有没有超过数组的长度，若不超过，结束返回；将数组元素提取出来；扩容1.5倍；扩容后还不满足，则扩至所需最短长度；将数组元素放回。

  • add()

两种添加元素的方式：
*一是根据下标插入元素，即在指定下标位置添加新元素，其他元素整体后移。

public void add(int index, T element){
        if(index >= size() || index < 0) {
            throw new ArrayIndexOutOfBoundsException();
        }
        ensureCapacity(size()+1);
        for(int i = theSize; i > index;i--)
        {
            theItems[i] = theItems[i-1];
        }
        theItems[index] = element;
        theSize++;
    }

进行元素添加操作时，要先判断数组是否越界，接着进行扩容的判断，然后将下标值后的数据依次后移，之后将元素值插入，最后进行元素个数的增加操作。
*二是直接添加元素，这就是在末尾填加新元素。

public int add(T element){
        ensureCapacity(size()+1);
        theItems[theSize++] = element;
        return size()-1;
    }

在末尾添加元素相对简单，扩容后直接赋值并把元素个数加一即可。

  • remove()
public T remove(int index){
        if(index >= size() || index < 0) {
            throw new ArrayIndexOutOfBoundsException();
        }
        T removeItem = theItems[index];
        for(int i = index; i < size()-1; i++)
        {
            theItems[i]=theItems[i+1];
        }
        theItems[theSize] = null;
        theSize--;
        return removeItem;
    }

这个方法返回了被删除元素的值，所以需要先记录了一下被删除元素，然后将后续元素前移，之后将最后一个元素置空减少元素个，最后返回被删除的元素值。注意：每次进行涉及到数组下标的操作时，都要先进行数组是否越界的判断(下同)。

  • get()
public T get(int index){
        if(index >= size() || index < 0) {
            throw new ArrayIndexOutOfBoundsException();
        }
        return theItems[index];
    }

根据下标获取元素值，只需要直接去找数组中对应下标的元素即可。

  • set()
public T set(int index, T newVal){
        if(index >= size() || index < 0) {
            throw new ArrayIndexOutOfBoundsException();
        }
        T old = theItems[index];
        theItems[index] = newVal;
        return old;
    }

此方法是修改对应下标位置的数组内元素值，需要返回被修改元素值，所以也是需要先记录一下对应位置原元素的值，然后赋新值，返回旧值。

  • indexOf()
public int indexOf(T element) {
        int index = -1;
        for(int i = 0; i < size(); i++)
        {
            if(element.equals(theItems[i]))
            {
                index = i;
                break;
            }
        }
        return index;
    }

获取元素第一次出现位置，需要从头遍历数组，找到所需元素后停止即可。

  • lastIndexOf()
public int lastIndexOf(T element){
        int index = -1;
        for(int i = size()-1; i >= 0; i--)
        {
            if(element.equals(theItems[i]))
            {
                index = i;
                break;
            }
        }
        return index;
    }

与indexOf()类似，从数组最后开始遍历即可。

zcyt085
关注
java学习笔记
csdnlxk98的博客
04-26 832
第一个Java程序Java语言的平台                JavaSE                                 JVM：保证Java语言跨平台 JavaME--Android                JRE：Java程序的运行环境         JavaEE                                 JDK：Java程序的开发环境 ...
JAVA学习笔记
NASA诺亚方舟
05-22 279
JAVA学习笔记 一 JDK安装 1.1环境变量配置 1.1.1 永久配置环境变量 打开方式：计算机-高级-环境变量 JAVA_HOME：自己建的系统变量，添加到JDK目录即可 //切记，不是用户变量 path：系统默认环境变量，添加两个bin文件，jdk\bin和jdk\jre\bin classpath：执行class文件时，指定优先搜索java类的存放路径 1.1.2 临时配...
Java泛型详解
chuanjiaoye5017的博客
11-10 547
Java泛型详解 Java泛型（generics）是JDK 5中引入的一个新特性，允许在定义类和接口的时候使用类型参数（type parameter）。声明的类型参数在使用时用具体的类型来替换。泛型最主要的应用是在JDK 5中的新集合类框架中。对于泛型概念的引入，开发社区的观点...
Java 泛型数组（ T[] arr = new T[N]）创建报错之谜！
manba
07-11 2104
今天小编在创建一个泛型数组的时候报了错。 代码如下: class Stack<T> { private T[] list; private int n; private Stack(int capacity) { list = new T[capacity]; } } 报错信息如下: Error:(15, 17) java: 创建泛型数组 从上面的错误信息可以推断出来Java不支持直接创建 T[] arr = new T[N]形式的
【Java数据结构】泛型
m0_62753430的博客
10-24 325
同样是钱，所以把钱的属性赋给美元和人民币都不会有错误，所以可以赋值。而读取（get）数据时候，有可能会有赋值操作，如get人民币对象赋值给钱，就会导致向上转型，会出错。（第一种使用泛型的方法）是什么道理？因为写入数据需要知道具体的类是什么，比如同样是钱，美元不能直接赋值给人民币。如，表示T一定是Number的子类。通配符的上界不能写入数据（不能set），只能读取数据（只能get）基本类型直接用== >
聊一聊-JAVA 泛型中的通配符 T，E，K，V，？
BASK2311的博客
01-07 233
Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许开发者在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
java中t_java中什么是T？
weixin_39630441的博客
02-12 1522
java中什么是T？T是Java泛型中的一个标记符号，代表Type(Java 类)。Java 泛型(generics)是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。(相关视频教程分享：java视频教程)Java泛型中的标记符含义：E - Element (在集合中使...
(完整版)最全的java学习笔记(必看).pdf
05-27
Java学习笔记 Java是一种流行的编程语言，广泛应用于Android应用程序开发、Web应用程序开发、桌面应用程序开发等领域。以下是Java学习笔记的摘要信息： 一、Java技术基础 * 1.1 编程语言：Java是一种面向对象的...
Java学习笔记(必看经典).pdf
最新发布
10-20
Java是一种广泛使用的面向对象编程语言，其核心设计原则之一就是"万物皆对象"。面向对象编程（Object-Oriented Programming, OOP）是相对于面向过程编程的一种编程范式，它强调将数据和操作数据的函数封装在一起，...
java学习笔记1
09-20
Java学习笔记1 Java学习笔记1是学习Java过程中的笔记，主要记录了Eclipse开发环境中的快捷键使用、编辑功能、查找和调试等知识点。 Eclipse快捷键 Eclipse中有许多快捷键，掌握这些快捷键可以大大提高开发效率。...
java t 用法_Java 泛型<T> T 与 T的用法
weixin_34831191的博客
02-15 1351
T 与 T 比较T是Type的首字母缩写；T 表示“返回值”是一个泛型，传递什么类型，就返回什么类型；而单独的“T”表示限制传递的参数类型。T的用法T表示返回值T是泛型，T只是一个占位符，用来告诉编译器，这个东西先给我留着，等我编译的时候再告诉你是什么类型。public class TTDemo {public static void main(String[] args){TTDemo ttDe...
「 Java基础-泛型 」一文说清Java泛型中的通配符T、E、K、V、N、？和Object的区别和含义
大白吃饱了吗的技术博客
02-16 3036
当我们在阅读源码的时候通常会看到如下所示代码中存在“E”、“T”或“？”,那么，这些大写字母到底有着怎样的含义呢？接下来我们具体讨论一下。/**/**Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许开发者在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。
java数据结构之数组
qq_41346335的博客
02-09 5689
数据结构对我们的程序员也是非常重要的，相当于一个基础学科，从今天开始，咱们再重新学习一下数据结构吧 1，首先我们要定义一下泛型，初始化成员变量，声明构造方法。 private T data[]; private int size; public MyArray(int capacity) { data = (T[]) new Object[capacity...
从字节码看java类型转换【 深入理解 (T[]) new Object[size] 】
weixin_34119545的博客
11-18 351
　　我们都知道，java中对类型的检查是很严格的，所以我们平操作时，也往往很小心。 　　如题： (T[]) new Object[size]，这种写法是一般我们是不会干的！但是有点经验的同学，还是会遇到这样写的。那么，今天咱们就来看看，像这样的写法对不对，也顺便深入理解java的类型转换机制吧！ 问题1： 如题 (T[]) new Object[size]  的写法对不对？ 　　答案是肯定的，没...
Java中的泛型T
weixin_48994585的博客
07-04 1253
在实例化的时候，就必须声明泛型具体是一个什么类型。extends Number>和
java t的使用_java中的t怎么用
weixin_36073697的博客
02-15 1233
T表示返回值是一个泛型，传递啥，就返回啥类型的数据，而单独的T就是表示限制你传递的参数类型，这个案例中，通过一个泛型的返回方式，获取每一个集合中的第一个数据， 通过返回值 T 和T的两种方法实现。T 用法返回值，直接写T表示限制参数的类型，这种方法一般多用于共同操作一个类对象，然后获取里面的集合信息啥的。public class Demo2 {public static void main(St...
Java中的＜T＞是什么？
热门推荐
NeiHan2020的博客
02-24 1万+
这种是 jdk1.5 引入的泛型机制，没有T这种类型，T是根据你输入的来动态匹配。假如你集合放入的String类型，那么你就可以使用List<String>，然后代码中所有出现T的地方都用String代替就可以了 ，放入的是Object类型，那么你就用List<Object>,同理。 其中T叫做通配符，常用的通配符有T,E,K,V分别表示类型、元素、键、值，当然这并不是硬性规定，而是大家形成的一种通识。 文章第一段来自java 里 泛型中 <T>代表什么类型呀？_百度
java 可变参数 T...
景月娇-Kathy
06-24 1825
T…(T是某种类型，…可变，所有T…就是某有类型的可变参数的意思） 常见数组操作 String[] values= new String[]{"jingyuejiao","caoxueliang"}; 可变数组操作 private static <T> T[] of(T...values){ return values; } String[] values1=of("jingyuejiao","caoxueliao","yuanr
JAVA学习笔记：入门篇
"Java学习笔记初步概述" 在Java学习的初期，我们首先会接触到的是Java程序的两种核心运行机制。Java程序的执行依赖于Java虚拟机（JVM），它负责将编译后的字节码文件转化为机器语言，使得Java代码能在不同的操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值