上图左侧只能存储同一类型的数据连续存储在列表中，既整型和整型，浮点型和浮点型，同类型的存储大小是一样的，因为是连续存储而且存储空间的大小是一样则可以通过索引值获取数据。

右侧则可以通过在列表中存储数据的内存地址来解决存储不同数据类型的问题，因为内存地址的大小是固定的，通过列表的索引值获取到数据的内存地址，然后再通过内存地址获取数据。



 



 



 

左边是一体式，表头和元素地址是连续存储的，可以通过偏移量既索引值直接跳过表头查找元素，直接访问。

右边是分离式，表头和元素的内存地址是分离的，列表先通过表头找到表头的相关信息，然后再通过表头知道元素的内存地址，来间接访问。

建立一个顺序表首先需要向系统申请多大的内存空间（表头），既这个表存储几个元素的最多个数和目前这个表当前的元素个数，，如果你先申请了8个存储元素的空间，实际上你有九个元素需要存储，则会出现有一个元素和另外八个元素不连续存储

所以只能向操作系统重新申请内存空间存储数据，把原表内的数据迁移到新表，且原表的数据内存地址会改变，原表的内存空间会被释放。

如果此时的结构是一体式，则表头的内存地址也要改变。

分离式则只需要把指向数据区的内存地址改变就可以，表头地址不需改变。

学习了一段时间的Java，我们对Java的基本知识有了一定的了解，今天再来聊聊数组。
Java内置数组的特点


数组的长度一旦确定则不可更改


数组只能存储同一类型的数据


数组中每个存储空间大小一致且地址连续


数组提供角标的方式访问元素


我们发现数组又有一些局限性，于是在使用时又会有一些疑惑，我们可以总结一下

Java内置数组的潜在问题
容量不够用时，怎么办？
指定位置插入或删除元素，怎么做？
数组对象只有length属性，能满足更多的需求吗？
动态数组的封装

有了问题，我们就有想法，尝试用学过的知识来解决
能否用面向对象的思想，将数组进行再度封装呢？
可以的，我们可以把数组的相关属性和相关行为封装在类中
类似字符串String类，形成如下的调用形式
String s="HelloWorld";
s.charAt(1);
s.compareTo("Hello");
s.equals("Hello");
s.repalce('l','L');


数组对象.排序()
数组对象.插入(元素)
数组对象.查找(角标)
这样大大方便了我们对数组的操作
那么如何封装动态数组

属性方面：

int size	       数组的有效元素个数
int capacity    数组的最大容量data.length
E[] data	       数据的存储容器

行为方面：

增()
删()
改()
查()
其他()

为什么要强调动态数组

动态数组是顺序存储结构的具体实现！
1）线性表的定义
零个或多个数据元素的有限序列

2）线性表接口List的定义


定义线性表的接口List

List支持泛型E

该List线性表中所存储的具体数据类型由外界决定
public interface List<E> extends Iterable<E>{
    //获取线性表中元素的有效个数
    int getSize();
    //判断线性表是否为空表
    boolean isEmpty();
    //在线性表指定的index角标处插入元素e
    void add(int index,E e);
    //在线性表的表头处插入元素e
    void addFirst(E e);
    //在线性表的表位处插入元素e
    void addLast(E e);
    //获取线性表中指定角标index处的元素
    E get(int index);
    //获取表头元素
    E getFirst();
    //获取表尾元素
    E getLast();
    //修改线性表中指定角标index处的元素为新元素e
    void set(int index,E e);
    //判断线性表中是否包含元素e
    boolean contains(E e);
    //查找元素e的角标(从左到又默认第一个出现的元素角标)
    int find(E e);
    //删除并返回线性表中指定角标index处的元素
    E remove(int index);
    //删除并返回表头元素
    E removeFirst();
    //删除并返回表尾元素
    E removeLast();
    //删除指定元素e
    void removeElement(E e);
    //清空线性表
    void clear();
}

创建线性表List的顺序存储结构实现类ArrayList
public class ArrayList<E> implements List<E>{
    //创建E类型的一维数组
    private E[] data;
    //维护元素个数
    private int size;
    //默认最大容量为10
    private static int DEFAULT_CAPACITY=10;
    }

先创建一个顺序表 ，重写函数来获取元素有效个数与判断是否为空
//创建一个默认大小的顺序表
    public ArrayList(){
        this(DEFAULT_CAPACITY);
        //data=(E[])(new Object[DEFAULT_CAPACITY]);
    }

    //创建一个容量由用户指定的顺序表
    public ArrayList(int capacity){
        if(capacity<=0) {
            throw new IllegalArgumentException("容量>0:" + capacity);
        }
        data=(E[])(new Object[capacity]);
        size=0;
    }

    //用户传入一个数组 将该数组封装成一个顺序表
    public ArrayList(E[] data){
        if(data==null){
            throw new IllegalArgumentException("数组不能为空");
        }
        this.data=(E[])(new Object[data.length]);
        for (int i = 0; i <data.length ; i++) {
            this.data[i]=data[i];
        }
        size=data.length;
    }

    @Override
    public int getSize() {
        return size;
    }

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

在指定角标插入元素时，如果数组已满，则需要扩容
@Override
    public void add(int index, E e) {
        if(index<0||index>size){
            throw new IllegalArgumentException("角标越界");
        }
        if(size==data.length){
            //扩容
            resize(data.length*2);
        }
        for (int i = size; i >index ; i--) {
            data[i]=data[i-1];
        }
        data[index]=e;
        size++;
    }
	private void resize(int newLength) {
        E[] newData=(E[])(new Object[newLength]);
        for (int i = 0; i < size; i++) {
            newData[i]=data[i];
        }
        data=newData;
    }
    @Override
    public void addFirst(E e) {
        add(0,e);
    }

    @Override
    public void addLast(E e) {
        add(size,e);
    }

获取指定元素位置
    @Override
    public E get(int index) {
        if(isEmpty()){
            throw new IllegalArgumentException("线性表为空");
        }
        if(index<0||index>=size){
            throw new IllegalArgumentException("角标越界");
        }
        return data[index];
    }

    @Override
    public E getFirst() {
        return get(0);
    }

    @Override
    public E getLast() {
        return get(size-1);
    }

修改线性表中指定角标index处的元素为新元素e
    @Override
    public void set(int index, E e) {
        if(isEmpty()){
            throw new IllegalArgumentException("线性表为空");
        }
        if(index<0||index>=size){
            throw new IllegalArgumentException("角标越界");
        }
        data[index]=e;
    }

查找元素e的角标(从左到又默认第一个出现的元素角标)
    @Override
    public boolean contains(E e) {
        return find(e)!=-1;
    }

在数组中查找是否含有指定元素e
    @Override
    public int find(E e) {
        if(isEmpty()){
            throw new IllegalArgumentException("线性表为空");
        }
        for (int i = 0; i < size; i++) {
            if(data[i].equals(e)){
                return i;
            }
        }
        return -1;
    }

删除并返回线性表中指定角标index处的元素
    @Override
    public E remove(int index) {
        if(isEmpty()){
            throw new IllegalArgumentException("线性表为空");
        }
        if(index<0||index>=size){
            throw new IllegalArgumentException("角标越界");
        }
        E ret=data[index];
        for(int i=index+1;i<size;i++){
            data[i-1]=data[i];
        }
        size--;
        if(size<=data.length/4&&data.length/2>=10){
            resize(data.length/2);
        }
        return ret;
    }

    @Override
    public E removeFirst() {
        return remove(0);
    }

    @Override
    public E removeLast() {
        return remove(size-1);
    }

删除指定元素e
    @Override
    public void removeElement(E e) {
        int index=find(e);
        if(index!=-1){
            remove(index);
        }else{
            throw new IllegalArgumentException("元素不存在");
        }
    }

清空线性表
    @Override
    public void clear() {
        size=0;
        data=(E[])(new Object[DEFAULT_CAPACITY]);
    }

    



Array：数组，申明数组的时候就要初始化并确定长度，长度不可变，而且它只能存储同一类型的数据，比如申明为String类型的数组，那么它只能存储String类型数据 
ArrayList：列表，需要先申明，然后再添加数据，长度是根据内容的多少而改变的，ArrayList可以存放不同类型的数据，在存储基本类型数据的时候要使用基本数据类型的包装类当能确定长度并且数据类型一致的时候就可以用数组，其他时候使用ArrayList




转载于:https://www.cnblogs.com/lph970417/p/10338324.html

R语言数据类型【转！！】Zhao-Pace  https://www.cnblogs.com/zhao441354231/p/5970544.html
 



      R语言用来存储数据的对象包括: 向量, 因子, 数组, 矩阵, 数据框, 时间序列(ts)以及列表, 下面讲意义介绍.

1. 向量(一维数据): 只能存放同一类型的数据
语法: c(data1, data2, ...), 访问的时候下标从1开始(和Matlab相同); 向量里面只能存放相同类型的数据.

> x <- c(1,5,8,9,1,2,5)
> x
[1] 1 5 8 9 1 2 5
> y <- c(1,"zhao")  # 这里面有integer和字符串, 整数自动转化成了字符
> y[1] 
[1] "1"

访问:

> x[-(1:2)]    # 不显示第1,2个元素
[1] 8 9 1 2 5
> x[2:4]       # 访问第2,3,4个元素
[1] 5 8 9

2. 因子(factors):  提供了一个处理分类数据的更简洁的方式
因子在整个计算过程中不再作为数值, 而是作为一个"符号"而已. 
factor(x=character(), levels, labels=levels, exclude=NA, ordered=is.ordered(x), nmax=NA)
x: 一个数据向量, 它将被转换成为因子;
levels: 用来指定因子可能出现的水平(默认也就是向量x里面互异的值, sort(unique(x)));它是一个字符向量(即每个元素是单个字符, 组成的一个向量), 下面的变量b就是一个字符向量(可以使用as.character()函数来生成). 
labels: 用来指定水平的名字;

> a <- c(6,1,3,0)
> b = as.character(a)
> b
[1] "6" "1" "3" "0"

exclude: 一个值向量, 表示从向量x里面剔除的水平值.
nmax: 水平数目的上界.


> factor(1:3)
[1] 1 2 3
Levels: 1 2 3
> factor(1:3, levels=1:6)
[1] 1 2 3
Levels: 1 2 3 4 5 6
> factor(1:6, exclude = 2)
[1] 1    <NA> 3    4    5    6   
Levels: 1 3 4 5 6


一般因子(factor) VS 有序因子(ordered factor)
      因子用来存放变量或者有序变量, 这类变量不能用来计算, 而只能用来分类或者计数. 一般因子表示分类变量, 有序因子用来表示有序变量.
创建一个因子:


> colour <- c('G', 'G', 'R', 'Y', 'G', 'Y', 'Y', 'R', 'Y')
> col <- factor(colour)  #生成因子
#labels里面的内容代替对应位置处的levels内容
> col1 <- factor(colour, levels = c('G', 'R', 'Y'), labels = c('Green', 'Red', 'Yellow'))
> levels(col)
[1] "G" "R" "Y"
> levels(col1)
[1] "Green"  "Red"    "Yellow"
> col2 <- factor(colour, levels = c('G', 'R', 'Y'), labels = c('1', '2', '3'))
> levels(col2)
[1] "1" "2" "3"
> col_vec <- as.vector(col2)
> class(col_vec)
[1] "character"
> col2
[1] 1 1 2 3 1 3 3 2 3
Levels: 1 2 3
> col_num <- as.numeric(col2)
> col_num
[1] 1 1 2 3 1 3 3 2 3
> col3 <- factor(colour, levels = c('G', 'R')) #levels里面没有'B',导致col3里面的'B'变成了<NA>
> col3
[1] G    G    R    <NA> G    <NA> <NA> R    <NA>
Levels: G R
> colour
[1] "G" "G" "R" "Y" "G" "Y" "Y" "R" "Y"


创建一个有序因子:

> score <- c('A', 'B', 'A', 'C', 'B')
> score1 <- ordered(score, levels = c('C', 'B', 'A'));
> score1
[1] A B A C B
Levels: C < B < A

3. 矩阵(matrix, 二维数据): 只能存放同一类型
语法: matrix(data, nrow = , ncol = , byrow = F) -- byrow = F表示按列来存放数据(默认), byrow=T表示按行存放数据;

> xx = matrix(1:10, 2, 5)
> xx
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    3    5    7    9
[2,]    2    4    6    8   10

4. 数组(大于等于三维的数据): 只能存放同一类型
语法: array(data, dim) -- data: 必须是同一类型的数据; dim: 各维的维度组成的向量;(怎么感觉和matlab里面的reshape函数那么像) 

> a = array(1:10,c(2,5))
> a
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    3    5    7    9
[2,]    2    4    6    8   10

5. 数据框(data frame)
数据框是一种矩阵形式排列的数据(类似于excel表格), 但是和矩阵不同的是, 它的每一列可以是不同的数据类型(还是和excel很像).
语法: data.frame(data1, data2,...) -- data1,...为每列的数据.


> name <- c("Mr A", "Mr B", "Mr C")
> group <- rep(1,3)
> scort <- c(58,15,41)
> df <- data.frame(name, group, scort)
> df
  name group scort
1 Mr A     1    58
2 Mr B     1    15
3 Mr C     1    41


数据访问:


> df$name
[1] Mr A Mr B Mr C
Levels: Mr A Mr B Mr C
  > df[1]
    name
  1 Mr A
  2 Mr B
  3 Mr C



6. 列表(list): 可以存放不同类型的数据
语法: list(name1=component1, name2=component2, ...)


> xx <- rep(1:2, 3:4)
> yy <- c('Mr A', 'Mr B', 'Mr C', 'Mr D', 'Mr E', 'Mr D', 'Mr F')
> zz <- 'discussion group'
> name.list <- list(group = xx, name = yy, decription = zz)    
> name.list
$group
[1] 1 1 1 2 2 2 2

$name
[1] "Mr A" "Mr B" "Mr C" "Mr D" "Mr E" "Mr D" "Mr F"

$decription
[1] "discussion group"




转载于:https://www.cnblogs.com/wwwwwei/p/10521252.html