RSS

Arquivo da tag: Java

Carregar uma partial view em uma div ASP.NET MVC

 type="text/javascript">
    $(document).ready(function () {
        $('#buttonId').click(function () {
            $('#divid').load('@Url.Action("About", "Home")');
        });
    });


<a id="buttonId">Load partial view or Any URL</a>
id="divid" style="height:100px; width:400px";>
Anúncios
 
Deixe um comentário

Publicado por em 18/01/2017 em Asp.Net MVC

 

Tags: , , , , , , , , , , ,

Livro Use a Cabeça! Javascript (Português)

O que você aprenderá com este livro? Você está pronto para dar um salto na arte de escrever páginas da web em HTML e CSS à criação de aplicações dinâmicas para web? Comece por aqui. Use a Cabeça! JavaScript é o seu passeio guiado para a emocionante e interativa criação de páginas da web. Criado para o seu cérebro, este livro abrange todos os fundamentos de JavaScript, das técnicas básicas de programação web, incluindo variáveis, funções e execução de loop, aos tópicos mais avançados como validação de formulário, manipulação de DOM, objetos personalizados, depuração – e até Ajax! Então, prepare-se… Os responsivos sites da web estão há algumas páginas de distância. Por que este livro parece tão diferente? Nós acreditamos que seu tempo é muito valioso para ser desperdiçado. Tendo como base a última pesquisa em neurobiologia, ciência cognitiva e teoria do aprendizado, Use a Cabeça ! JavaScript tem um visual rico, projetado na forma como seu cérebro funciona; não se trata de uma abordagem pesada que faz com que você caia em sono profundo.

Compre com segurança da Amazon.com

Compre Agora !

 
Deixe um comentário

Publicado por em 23/10/2015 em Livros

 

Tags: , , , , , , , , , , , ,

Livro Use A Cabeça! Java (Português)

 Use a Cabeça! Java é uma experiência completa de aprendizado em programação orientada a objetos (OO) e Java. Projetado de acordo com princípios de aprendizado simples, este livro mostrará de aspectos básicos da linguagem a tópicos avançados que incluem segmentos, soquetes de rede e programação distribuída. O mais importante é que você aprenderá a pensar como um desenvolvedor orientado a objetos. E não irá apenas ler: você vai participar de jogos, resolver quebra-cabeças, refletir sobre mistérios e interagir com Java de formas nunca imaginadas. No decorrer da leitura, você escreverá muitos códigos Java reais.

COMPRE COM A SEGURANÇA DA AMAZON.COM

Compre Agora !

 
Deixe um comentário

Publicado por em 23/10/2015 em Livros

 

Tags: , , , , , , , , , , , , , , , , , ,

Use a Cabeça! Padrões de Projetos (Português)

Como você sabe que não quer reinventar a roda (ou, pior, um pneu furado), então você busca padrões de projetos. As lições aprendidas por aqueles que se depararam com os mesmos problemas de desenvolvimento de software. Os padrões de projetos permitem que você aproveite as melhores práticas e a experiência de outros e gaste seu tempo com… outra coisa. Algo mais estimulante. Algo mais complexo. Algo mais divertido. Então você quer aprender: Quais são os padrões que realmente importam; Quando e por que devem ser usados; Como aplicá-los em seus próprios projetos; Quando não usá-los (como evitar a febre dos padrões); Quais são os princípios de design da programação orientada a objetos em que os padrões se baseiam. Porém, o mais importante é que você quer aprender mais sobre padrões de projetos de uma maneira que não o faça dormir. Se já leu algum livro da série Use a Cabeça!, você já sabe o que o espera um formato visualmente rico projetado para se adaptar à forma como seu cérebro funciona. Usando as últimas descobertas da neurobiologia, ciência cognitiva e teoria do aprendizado, Use a Cabeça! Padrões de Projetos 2a Edição colocará os padrões no seu cérebro de maneira permanente. De uma forma que o tornará mais apto para resolver problemas de desenvolvimento de software e mais eficiente para discutir a linguagem dos padrões com outros membros da sua equipe.

    Compre Agora com a segurança da Amazon.com

Compre Agora !

 
Deixe um comentário

Publicado por em 23/10/2015 em Livros

 

Tags: , , , , , , , , , , , , , , , , , , , , , ,

Lista duplamente encadeada em Java

Conceito

Listas duplamente encadaedas são um tipo de estrutura de dados onde um elemento dentro da lista contêm uma referência ao elemento sucessor e anterior.

Representação de uma lista dinâmica duplamente encadeada

Numa lista cada elemento, ou nó, é composto normalmente por uma variável que guarda a informação e ponteiros (referências a endereços de memória) que permitem a ligação entre os vários nós desta lista.

Esses ponteiros em uma lista simplesmente encadeada apontam para o próximo nó da lista, até que o último aponte para uma região de memória nula. Assim, é possível saber onde a lista termina.

Já a lista duplamente ligada além de saber o próximo nó, cada elemento também conhece o nó anterior a ele na lista. Isso facilita e melhora o desempenho de algumas operações executadas sobre a lista como por exemplo remover um elemento, mostrar os elementos na ordem inversa (do último para o primeiro elemento), etc.

Isso tembém facilita na alocação dinamica de objetos, até agora vimos somente alocação de objetos em vetores, agora podemos utilizar essa lista para alocar dinamicamente nosso objeto, no exemplo usarei o info como inteiro só para o tutorial não ficar extenso, mas você pode substituir o inteiro por um objeto, mas ao substituili, não esqueça de instância-lo…

Vamos ao código:

Primeiro implementaremos a clase nó:

package listduplenc;

public class No
{
/* as variaveis ant e prox são do tipo No pois
irão receber o endereço dos outros objetos
do tipo No */
private No ant, prox;
private int info;
//construtor
public No(No ant,No prox,int info)
{
this.ant=p_ant;
this.prox=p_prox;
this.info=info;
}
//getter e setter
public No getAnt() { return ant; }
public No getProx() { return prox; }
public void setAnt(No p_ant) { ant=p_ant; }
public void setProx(No p_prox) { prox=p_prox; }
public int getInfo() { return info; }
public void setInfo(int elemento) { info=elemento; }
}

E esta criada nossa classe nó… mas ai você vem e me pergunta… sóóóóóó issoooooo… a grande jogada da classe nó não é a quantidade de codigo mas sim as variaveis ant e prox que guardam o endereço de outros objetos do tipo nó

Agora vamos a classe que irá utiliza os nós:

package listduplenc;

public class Lista {
/* Aqui criamos 2 variaveis do tipo No
para não perdermos a nossa lista
*imagine a lista como um varal… e
os nós como roupas… o ant e prox
do nó será nossos pregadores e os
bambus que seguram o varal são as
variaveis inicio e fim… se essas
variaveis perderem seu valor é como
se soltasse o fio do varal…
continuaremos a ter 2 bambus mas não
teremos mais o varal… */
private No inicio;
private No fim;

//construtor
public Lista()
{
inicializa();
//chama inicializa para economizar codigo
}

public void inicializa()
{
inicio=null;
fim=null;
//inicializa faz a lista ficar vazia
}

/* ai vem a famoza pergunta…se eu tenho uma
lista cheia e pego meu inicio e fim e seto
eles para que a lista esteja vazia.. e meus
nós que ja instanciei??? Bom quando um objeto
no java (no caso o nó) perde sua referencia
(no caso o inicio e fim) o próprio java retira
da memória o que está sobrando quem faz isso é
o Garbage Collector… ou como preferir…
coletor de lixo */

//aqui fazemos uma lista para inserir somente no final
public void insereNoFim(int info){
//declaramos e instanciamos a variavel caixa
//do tipo nó. seu anterior vai ser o fim
//pois estamos inserindo depois do fim
No caixa = new No(inicio,null,info);
if (inicio==null)//se lista estiver vazia
inicio = fim = caixa;
else{
//seta prox do No do fim para receber caixa
fim.setProx(caixa);
fim = caixa;
}
}

//aqui fazemos uma lista para inserir somente no comeco
public void insereNoComeco(int info){
//declaramos e instanciamos a variavel caixa
//do tipo nó. seu proximo vai ser o incio
//pois estamos inserindo antes do inicio
No caixa = new No(null,inicio,info);
if (inicio==null)//se lista estiver vazia
inicio = fim = caixa;
else{
//seta ant do No do inicio para receber caixa
inicio.setAnt(caixa);
inicio = caixa;
}
}

public void exibeLista()
{
No aux;
aux=inicio;
while (aux!=null)
{
System.out.println(aux.getInfo());
aux=aux.getProx();
}
}

public No Busca_Exaustiva(int elemento)
{
No p=inicio;
while ((p!=null) && (p.getInfo()!=elemento))
{
p=p.getProx();
}
if ((p!=null) && (p.getInfo()==elemento))
return p;
else return null;
}

//no remove temos 5 casos a considerar
public void removeLista(int elemento)
{
No pos;
pos=Busca_Exaustiva(elemento);
if (pos!=null)//1- se existe o No a ser deletado
{
if (inicio!=fim)//2- se só existe um Nó na lista
{
if (pos==inicio)//3- se o Nó esta no começo
{
inicio=pos.getProx();
pos.getProx().setAnt(null);
}
else
if (pos==fim)//4- se o Nó esta no fim
{
fim=pos.getAnt();
pos.getAnt().setProx(null);
}
else//5- se o no esta no meio
{
pos.getAnt().setProx(pos.getProx());
pos.getProx().setAnt(pos.getAnt());
}
pos.setAnt(null);
pos.setProx(null);
}
else
{
inicio=null;
fim=null;
}
}
else
System.out.println(‘Elemento nao encontrado’);
}
}

Agora vamos fazer uma classe principal para nossa aplicação:

package listduplenc;

public class Aplicacao {
Lista lista;
public Aplicacao()
{
lista=new Lista();
}

public void executa()
{
for (int i=1 ; i&lt;=5 ; i++)
lista.insereLista_noFinal(i);
System.out.println(‘Lista inserindo no final’);
lista.exibeLista();
System.out.println(‘\n\n’);

System.out.println(‘Lista inserindo no inicio (Tipo Pilha)’);
lista.insereLista_tipoPilha(50);
lista.insereLista_tipoPilha(40);
lista.insereLista_tipoPilha(30);
lista.exibeLista();

//Removendo alguns elementos (30,1,5)
lista.removeLista(30);
lista.removeLista(1);
lista.removeLista(5);
//Lista após remover alguns dos elementos (30,1,5)
System.out.println(‘\n\nDepois de Remover os elementos (30,1,5)’);
lista.exibeLista();
}

public static void main(String args[])
{
Aplicacao a = new Aplicacao();
a.executa();
}
}”

//

Lista Simplesmente Encadeada(inserir no meio)

public class Lista{

private No first; //Primeiro no da lista

public int insere(No novoNo){

if(first == null){
first = novoNo;
}else{
No noAnterior = first;

while((noAnterior.getNext() != null)&&(noAnterior.info <novoNo.info)){
noAnterior = noAnterior.getNext();
}

No aux = noAnterior.getNext();

noAnterior.setNext(novoNo);
novoNo.setNext(aux);
}
}”

//

Lista simplesmente encadeada


public class Lcad {
StringNoSimples primeiro, ultimo;
int numero_nos;
public Lcad() {
primeiro = ultimo = null;
numero_nos = 0;
}
public void insereNo_Ini (StringNoSimples novoNo) {
novoNo.prox = null;
if (primeiro != null) {
novoNo.prox = primeiro;
primeiro = novoNo;
}
else {
if (primeiro == null) {
primeiro = novoNo;
ultimo = novoNo;
}
}
}
public void insereNo_Fim (StringNoSimples novoNo) {
novoNo.prox = null;
if (primeiro == null) {
primeiro = novoNo;
ultimo = novoNo;
}
if (ultimo != null) {
ultimo.prox = novoNo;
ultimo = novoNo;
}
}
public void listarNo() {
StringNoSimples temp_no = primeiro;
int i = 0;
while (temp_no != null) {
System.out.println (‘Cliente: ‘+temp_no.valor);
temp_no = temp_no.prox;
i++;
}
}
}

}
}

 
Deixe um comentário

Publicado por em 22/11/2009 em Estudos Java

 

Tags: