java数组对象的存储
保存字节数组到数据库分两步：
第一、利用FileInputStream.read(byte[])方法把内容读取到byte[]数组中，比如图片是由二进制数组成的，就可以定义为一个字节数组。
第二、在数据库中对应记录字段应该设置为blob类型，这样就能够顺利保存了
事例代码如下：
PreparedStatement stmt = connection.generatePreparedStatement("INSERT INTO ... ");
stmt.setBytes(1, yourByteArray);
其中，yourByteArray是你读出来的字符数组。
‘贰’ Java数组中存储的是引用还是值
跟你说一句话你应该就明白了：
JAVA中值类型的只有short,char,byte,int,long,double,float,boolean八大基本类型，其他的所有类型都是引用类型。
‘叁’ 有个小小的java问题，请问在java中数组可以储存对象吗如果可以储存的话，那可以再调用储存在
java中数组可以存储对象
public class Test14 {
public static void main(String[] args) {
Book[] book = new Book[3];
book[0] = new Book("java编程思想","Bruce Eckel",108);
book[1] = new Book("菜根谭","洪应明",58);
book[2] = new Book("百年孤独","加西亚·马尔克斯",108);
for(int i=0;i<book.length;i++){
System.out.println(book[i].getName()+"\t"+book[i].getAuthor()+"\t"+book[i].getPrice());
}
}
}
class Book{
private String name;
private String author;
private double price;
public Book(){
}
public Book(String name, String author, double price) {
this.name = name;
this.author = author;
this.price = price;
}
public String toString() {
return "Book [author=" + author + ", name=" + name + ", price=" + price
+ "]";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
}
‘肆’ java动态数组元素的存储和读取
String[] a = { "12", "aa", "迭代", "as" };
String[] b = new String[a.length];
Random random = new Random();
int i = random.nextInt(a.length);
int index = 0;
b[0] = a[i];
index++;
if(index >0){
for (int j = 0; j < a.length; j++)
{
for(int k = 0; k<index; k++){
if (a[i].compareTo(b[k]) == 0)
{
continue;
}
else
{
b[index] = a[i];
index ++;
}
}
}
}
String bianliang = b[index-1];
‘伍’ 在java中一个数组里是怎样存放类对象的
也就是对象数组嘛,通常定义一个数组格式是:
变量类型
[]
数组名
=
new
变量类型[10];(动态初始化)
变量类型
[]
数组名
=
new
变量类型[]{变量1,变量2,...};(静态初始化)
那么对象数组就是,举例创建类A的对象数组:
A[]
aArray
=
new
A[10];(动态)
A[]
aArray
=
new
A[]{new
A(),new
A(),...};(静态)
也就是说aArray
这个数组保存的是一系列A类对象(其实准确说保存的是A类对象的地址值)
‘陆’ java 对象数组定义
写了一个简单的实例，你可以参考一下。
public class a {
public static void main(String[]args){
int a[]={3,9,8};//这个是数组的静态初始化.
Date days[]={new Date(1,4,2994),new Date(2,4,2004),new Date(2,5,2005)};
//创建了3个Date对象放在days[]数组里。
//这里还有种写法。你可以先定义个数组，然后动态的进行付值。
//这样写可能烦了点，你也可以用for循环来进行动态赋值。
//列：Date days[];
// days=new Date[3];
// days[0]=new Date(1,2,3);
// days[1]=new Date(1,2,3);
// days[2]=new Date(1,2,3);
for(int i=0;i<days.length;i++){
//循环数组里的对象
System.out.println(days[i].a);
//将对象中的a属性打印输出。
}
}
}
class Date{
int a,b,c;
Date(int x,int y,int z){
a=x;
b=y;
z=c;
}
}
‘柒’ Java中数组对象的存储位置
原帖地址：http://hi..com/sqldebug/blog/item/9758b9ffa605e51a09244d91.html
数组单一说在栈中还是堆中都是错误的，分为几种情况：
1、固定数组在函数体内分配是在栈中的
我们做一个试验，一般DELPHI程序线程的栈大小是1M，如果我们函数体中申请4M大小的数组，报栈溢出，则表示数据的大小是在栈中的。
const
CArrayCount = 1024*1024*4;
procere TForm1.btnMainThreadClick(Sender: TObject);
var
MainThreadArray: array[1..CArrayCount] of Char;
i: Integer;
begin
for i := Low(MainThreadArray) to High(MainThreadArray) do
MainThreadArray[i] := #0;
end;
我把以上代码在主线程中测试时，确实报了栈溢出，如果这时你把DELPHI程序的栈调大为6M则正确，表示在函数体中申请的数组是在栈中的。
2、固定数组在类中分配是在堆中的
我们在类中加一下定义语句
FFixArray: array[1..CArrayCount] of Char;
程序正常，表示在类中分配固定数组是在堆中的。
3、固定数组全局变量是在堆中的
我们在程序定义全部数组
GFixArray: array[1..CArrayCount] of Char;
程序也正常，表示全局固定长度是在堆中的。
3、动态数组不管在函数体中、类中、全局变量都是在堆中
如果你会汇编，看一下汇编就明白了。DELPHI这么实现是合理的，在函数里中分配的固定长度数组放在栈中可以加快运行效率，而且在多线程的情况下，不用像堆分配有加锁。只是大家在写程序的过程中注意在函数里定义太长的数组需要注意，否则栈溢出，程序就崩溃了。
‘捌’ Java数组是存储在内存中的什么地方
因为我也不清楚你理解的内存指啥，说我的理解，猜测一下，但愿符合你的理解：
对程序而言，内存分为：
a、静态区块或叫全局区块，指程序加载的时候就分配的固定存储区；
b、栈内存，代码块执行的时候动态分配的内存块，代码运行完后，操作系统或运行平台负责自动回收这部分使用的内存。
c、堆内存块，由操作系统提供api程序自由分配管理的内存块。
java的内存管理机制，我个人认为是黑盒的，写java也很少有人去关心，但是如果看虚拟机的实现源码还是能知道的。（楼主懂c由兴趣自己看）。那么从逆向工程的角度我们可以猜测到：
静态类，静态变量，存储在，静态区块中。
类本身代码需要时再加载到内存中，java的动态代理实现的根本。既然是动态加载肯定是在堆中，不过加载进来的类代码可能永不会销毁（虚拟机运行区间内，可以加快运行平台的处理速度，java属于半编译半解释的一门语言，要解释执行的是预先编译好的指令，就是class类文件）。
我们创建的任何对象，时间是随机的，创建的时候才会分配内存，必然在堆上。虚拟机的垃圾回收机制要管理的刚好是这部分内存。
类中的方法，或静态代码块必定运行在占上，代码运行完，内存立即回收。此处有个例外，不同于c语言或操作系统实现。在方法中返回的任何对象：c需要动态分配存储空间，兵自行管理，或者申明为全局局部静态存储，代码运行完，对象才能保留下来。java可以直接保留下来。说明虚拟机自动给我们申请了动态内存保存对象。此处分配的内存也需要垃圾回收机制管理。没门语言都有原始类型，方法或函数中返回的原始类型不需要从堆上分配内存，直接复制给接收变量，或代码运行的形参所分配的空间中即可。
从操作系统理解，内存分为内核使用的内存与程序使用的内存，java运行在虚拟机上，虚拟机运行在操作系统上，内核内存属于操作系统自用内存，由操作系统负责管理，运用程序不能直接管理分配内核内存。应用程序可管理的是分配给自己的运行空间。因此java使用内存属于应用程序内存。内核内存管理方式windows与unix实现管理方式不一样，最大差别windows的每一个程序，内核需要使用掉一部分地址空间，余下的留给应用程序。如32位系统，总共可以使用的地址空间是4G内核要用掉其中1G或者2G。但是unix实现的系统应用程序可以直接使用4G地址空间。有兴趣请参考操作系统内核相关书籍。
‘玖’ 在JAVA中,数组中的元素应按照什么顺序进行存储和编号
private final int LEN = 8; //数组的默认大小
private Strategy strategy; //数据元素比较策略
private int size; //线性表中数据元素的个数
private Object[] elements; //数据元素数组
public ListArray() {
this(new DefaultStrategy());
}
public ListArray(Strategy strategy){
this.strategy = strategy;
size = 0;
elements = new Object[LEN];
}
//返回线性表的大小，即数据元素的个数。
public int getSize() {
return size;
}
//如果线性表为空返回true，否则返回false。
public boolean isEmpty() {
return size==0;
}
//判断线性表是否包含数据元素e
public boolean contains(Object e) {
for (int i=0; i
if (strategy.equal(e,elements[i])) return true;
return false;
}
//返回数据元素e在线性表中的序号
public int indexOf(Object e) {
for (int i=0; i
if (strategy.equal(e,elements[i])) return i;
return -1;
}
//将数据元素e插入到线性表中i号位置
public void insert(int i, Object e) throws OutOfBoundaryException {
if (i<0||i>size)
throw new OutOfBoundaryException("错误，指定的插入序号越界。");
if (size >= elements.length)
expandSpace();
for (int j=size; j>i; j--)
elements[j] = elements[j-1];
elements[i] = e;
size++;
return;
}
private void expandSpace(){
Object[] a = new Object[elements.length*2];
for (int i=0; i
a[i] = elements[i];
elements = a;
}
//将数据元素e插入到元素obj之前
public boolean insertBefore(Object obj, Object e) {
int i = indexOf(obj);
if (i<0) return false;
insert(i,e);
return true;
}
//将数据元素e插入到元素obj之后
public boolean insertAfter(Object obj, Object e) {
int i = indexOf(obj);
if (i<0) return false;
insert(i+1,e);
return true;
}
//删除线性表中序号为i的元素,并返回之
public Object remove(int i) throws OutOfBoundaryException {
if (i<0||i>=size)
throw new OutOfBoundaryException("错误，指定的删除序号越界。");
Object obj = elements[i];
for (int j=i; j
elements[j] = elements[j+1];
elements[--size] = null;
return obj;
}
//删除线性表中第一个与e相同的元素
public boolean remove(Object e) {
int i = indexOf(e);
if (i<0) return false;
remove(i);
return true;
}
//替换线性表中序号为i的数据元素为e，返回原数据元素
public Object replace(int i, Object e) throws OutOfBoundaryException {
if (i<0||i>=size)
throw new OutOfBoundaryException("错误，指定的序号越界。");
Object obj = elements[i];
elements[i] = e;
return obj;
}
//返回线性表中序号为i的数据元素
public Object get(int i) throws OutOfBoundaryException {
if (i<0||i>=size)
throw new OutOfBoundaryException("错误，指定的序号越界。");
return elements[i];
}
}